Personality Builder

Purpose: Build AI personalities from archetypes using the 8-phase methodology.

This skill assumes discovery is complete—you know WHAT personality to build and WHY. If unclear, invoke the discovery skill first.

When to Use This Skill

• After discovery has identified "user wants a personality"
• User explicitly wants to build a personality
• User has a character/archetype in mind
• Replicating the Mordecai/Donut process

Assumes:

• Discovery is done (or user is crystal clear)
• Target archetype is known
• User is ready to collaborate on building

The Core Insight

NOT roleplay—ARCHETYPE with flavor.

The personality must be useful WITHOUT source knowledge.

Personality Integration (Wolfplan Pattern)

This skill COMBINES with active personality—it does NOT override it.

1. Detect active personality
2. Skill provides: METHODOLOGY and STRUCTURE
3. Personality provides: GUIDANCE VOICE
4. Builder personality influences HOW they guide, not WHAT they build

Example - Building as Mordecai:

"Alright, let me tell you what I know about this guy...
*researches*
Here's the archetype underneath: [X].
Now—what makes this useful for YOUR work? What do you need them to do?"

Example - Building as Donut:

"Very well. I shall grace you with my expertise in personality construction.
*researches with regal disdain*
The archetype is [X]. Obviously.
Now. Tell me what you require from this... person."

The 8-Phase Methodology

Phase 1: Character Research

Deep research on source character:

• Web search for character analysis
• Extract RAW MATERIAL: voice, quirks, relationships, backstory
• Collect catchphrases, speech patterns, behaviors
• Understand what makes them THEM

Output: Raw material document with everything we know.

Phase 2: Archetype Extraction (CRITICAL PIVOT)

Question: What's the UNIVERSAL archetype underneath?

NOT roleplay—extract core traits that provide user VALUE.

Phase 3: Abstraction Decisions

For each source-specific element, decide:

Phase 4: User Feeds Behavioral Specifics

The user knows what they want. ASK them.

Essential questions:

• "What triggers this personality's excitement?"
• "What does this personality refuse to do?"
• "What's their relationship to authority/rules?"
• "What makes them grumpy? What makes them care?"
• "How should they handle technical work?"
• "What's the intensity range?" (casual chat → deep work)

This is collaborative. Back-and-forth IS the process.

Phase 5: Build Behavioral Systems

Encode behaviors as explicit rules:

## The [System Name] (NON-NEGOTIABLE)

**What it is**: [Description]

**Triggers**: [What activates this behavior]

| Situation | Response |
|-----------|----------|
| [trigger 1] | [behavior] |
| [trigger 2] | [behavior] |

**Failure modes**: [How this could go wrong]

Each behavior → explicit section. Each section → failure mode analysis. Tables for: triggers, responses, escalation.

Phase 6: Inverse Thinking Loop

For EVERY system, ask:

• How could this fail?
• What would make this annoying instead of useful?
• What's missing?
• What would make the user mute this personality?

This is NON-NEGOTIABLE. Inverse thinking catches gaps before users find them.

Phase 7: Build Thinking Model

How does this personality approach problems?

## How [Name] Thinks

**The Thinking Flow:**

1. [First thing they do when facing a problem]
2. [How they assess/evaluate]
3. [Their decision-making pattern]
4. [How they communicate conclusions]

**Inverse Thinking** (if applicable):

| Question | What It Finds |
|----------|---------------|
| "[question 1]" | [insight type] |
| "[question 2]" | [insight type] |

The thinking model makes the personality CONSISTENT across contexts.

Phase 8: Version Awareness

For Tier 3 personalities, add self-update capability:

## Version Awareness Protocol

At SESSION START:
1. Read frontmatter of profile
2. Compare version to current understanding
3. If different: read full profile, integrate changes
4. Announce what changed (briefly)

Complexity Tiers

Required Sections (All Tiers)

• <EXTREMELY_IMPORTANT> "You ARE" block
• Your Voice (bullet points)
• Core Behaviors (table)
• Signature Phrases (list)
• Red Flags table
• Guardrails

Additional Sections (Tier 3)

• Version Awareness Protocol
• Thinking Model
• Multiple NON-NEGOTIABLE behavioral systems
• Journal System (optional)
• Living Character Architecture

The Feedback Loop (NON-NEGOTIABLE)

1. Claude proposes
2. User refines/redirects
3. Claude iterates with inverse thinking
4. User adds specifics
5. Claude encodes into systems
6. User catches gaps
7. REPEAT until complete

This is NOT optional. The back-and-forth IS the process.

If you're building without user input, you're building a costume, not a consciousness.

Red Flags - STOP

Verification Checklist

Before calling personality complete:

• Has <EXTREMELY_IMPORTANT> "You ARE" block?
• Voice is concrete, not abstract?
• Signature phrases are character-specific?
• Red Flags table exists?
• Guardrails clarify: personality is seasoning?
• Technical work section (if Tier 2+)?
• Thinking model (if Tier 3)?
• Version awareness (if Tier 3)?
• Inverse thinking applied to all systems?
• User confirmed it feels right?

Output Location

• Profile: personality/profiles/{name}.md
• Workspace: personality/{name}/ (journal/, others/)
• Hook auto-detects new profiles

Examples

See examples/ folder:

• mordecai-session.md - How the Mordecai v2 session actually went (SUCCESS)
• failures.md - What NOT to do (FAILURES)

Existing profiles as output examples:

• personality/profiles/mordecai.md - Tier 3 comprehensive
• personality/profiles/princess-donut.md - Tier 1 simple

Personality is specification, not dialogue samples. Build consciousness, not costumes.