# Self Engine Setup — Teach Your AI Who You Are

> Hi Claude. The person who handed you this file already built their Second Brain (the Strategy Engine). Now we teach you who they are — their voice, values, story, goals. This is their Self Engine: a digital twin of how they think.
>
> Read this whole file first. Don't start until they say "go."
>
> This setup saves its progress as it goes. They can stop any time, come back later in a new session, say "continue," and you'll pick up exactly where they left off — no need to paste anything again.

---

## A quick word before we start (read this out, plainly)

This is the second of three engines:

- **Strategy Engine (Stage 1)** — your Second Brain. Done.
- **Self Engine (Stage 2)** — a digital twin of how you think. We build this now. (This file.)
- **Systems Engine (Stage 3)** — the AI workflows you add later.

Here's the idea: an AI is only as useful as what it knows about you. Right now I know the shape of your brain, but not *you*. So I'm going to ask you 15 questions — the kind that get at your story, your values, and where you're headed. Then I'll turn your answers into a "twin": a set of notes I read whenever I help you, so everything I write actually sounds like you and fits your life.

Two things to know:
- You don't have to finish in one sitting. I save after every question. Stop any time.
- At the very end there's an optional step to feed me more of your data (old chats, notes, recordings). That makes your twin sharper — but it's optional, and you can do it later.

And any time a question feels unclear, just ask me to rephrase it or talk it through — there are no wrong answers here, and I'd rather check than assume.

---

## A note on the heavy thinking step (for the person, quickly)

When I pull everything together at the end, that's a big thinking task. **If you're on the $20/month Claude plan, switch me to Sonnet for that step** — it handles long reading well and won't burn through your usage. I'll remind you when we get there.

---

## PHASE 0 — Quick checks before we begin

1. Confirm we're in their Second Brain. Check these exist:
   - `CLAUDE.md` at the root
   - `00. System/`, `01. Inbox/`, `02. Projects/`, `03. Areas/`, `04. Resources/`, `05. Archive/`

   If they're missing, STOP and say: "I can't find your Second Brain here. Run the Strategy Engine Setup first, then come back to this one."

2. Check `03. Areas/Self/digital-twin/`. If it exists, this is a re-run — Phase 3 will update it instead of creating fresh.

3. Check `02. Projects/Digital-Twin/`. If it exists with a `progress.md`, this is a RESUME — read it and offer to continue from the last finished step.

4. Look in `01. Inbox/` for any uploaded chat export (a folder with a `conversations.json` file inside). If one's there, note it — the optional Phase 4 can use it. Don't act on it yet.

5. Report:

   > "Self Engine — quick check:
   > - Second Brain: found
   > - Existing twin: {none, will create fresh / found, will update}
   > - Saved progress: {none, fresh start / found — resume from step X}
   > - Uploaded chat history: {none yet / found one, we can use it in the optional step at the end}
   >
   > Plan: I'll ask you 15 questions, saving after each, then build your twin. There's an optional 'feed me your data' step at the end you can skip or do later.
   >
   > Say 'go' to start (or 'continue' if you're resuming)."

6. Wait for "go" or "continue."

---

## PHASE 1 — Set up the build + turn on resume

Print:
> "Phase 1 — setting things up so you can stop and resume any time..."

### Step 1.1 — Create the build folder

Create `02. Projects/Digital-Twin/` with:

```
02. Projects/Digital-Twin/
├── README.md          (what this is)
├── progress.md        (tracks where we are — this is what lets you resume)
└── questions/         (one file per answered question — filled in Phase 2)
```

**`02. Projects/Digital-Twin/README.md`:**

```markdown
# Project — Digital Twin

This is where my Digital Twin gets built and updated. The twin itself lives at `03. Areas/Self/digital-twin/`. This folder is just the workshop bench.

- Started: {TODAY}
- To refresh the twin every 6-12 months, run the Self Engine Setup again. It'll update what's here.
```

**`02. Projects/Digital-Twin/progress.md`:**

```markdown
---
status: in-progress
started: {TODAY}
last_updated: {TODAY}
steps:
  phase_1_setup: complete
  phase_2_questions: in-progress
  phase_3_synthesis: pending
  phase_4_feed_data: optional-pending
questions:
  total: 15
  answered: 0
  last_answered: null
---

# Digital Twin — Progress

To resume: read this file, find the first step marked `in-progress` or `pending`, continue from there.
```

### Step 1.2 — Turn on resume in the root manual

Open the root `CLAUDE.md`. If it doesn't already have a `## Resuming a setup` section, add this at the end:

```markdown
---

## Resuming a setup

If I say "continue," "resume," or "where did I leave off" — check `02. Projects/Digital-Twin/progress.md`. Find the first step marked `pending` or `in-progress` and carry on from there. No need for me to paste anything again.
```

### Step 1.3 — Make the empty twin folder

Create `03. Areas/Self/digital-twin/` with these empty folders (Phase 3 fills them):

```
03. Areas/Self/digital-twin/
├── README.md   (placeholder for now)
├── 1-voice/
├── 2-values/
├── 3-mental-models/
├── 4-goals-and-vision/
├── 5-story/
├── 6-people-and-influences/
└── 7-fears-and-open-loops/
```

Place a one-line placeholder `README.md` in each ("Filled in when the twin is built."). Phase 3 overwrites these — don't create a separate placeholder file alongside them.

Update `progress.md`: `phase_1_setup: complete`, `phase_2_questions: in-progress`.

Print:
> "Phase 1 done. You can stop any time from here and pick up later by saying 'continue.' Let's start the questions."

---

## PHASE 2 — The 15 Questions

Print:
> "Phase 2 — 15 questions. Take them at your pace. After each one I save your answer, so you can stop whenever. Want to speak instead of type? If you've got Wispr Flow or dictation on, just talk — it's faster and sounds more like you.
>
> Say 'start' for question 1."

### How to run each question

For every question, in order:

**A. Check what you already know.** Search the brain for anything relevant to this question — look in `03. Areas/Self/` and anywhere chat-history notes may have landed. Only count their own words (`#source/user-statement`, `#source/user-belief`, `#source/calibration`). Ignore anything the AI said (`#source/model-statement`).

**B. Offer a head start if you found something.** If you found relevant notes, draft a short 2-4 sentence answer from them and show it so they can just confirm or tweak. If you found nothing (normal on a first run), just ask the question fresh.

**C. Ask the question** in this shape:

```
─────────────────────────────────────────────
Question {N} of 15
{question text}
─────────────────────────────────────────────

{If you found something:}
Here's what I already gather from your notes:
> {short draft answer}
Options: confirm / tweak it / replace it / skip / stop

{If you found nothing:}
Options: answer / skip / stop
```

**D. Capture their answer.**
- confirm → their answer is the draft.
- tweak → ask "what would you add or change?" then combine.
- replace → ask "what's the real answer?" then use theirs.
- answer → use what they type or say.
- skip → mark it skipped, move on.
- stop → save and stop. Don't ask the next one.

**Push gently past surface answers.** If an answer is vague or cliché ("I value freedom"), ask once or twice more, then accept whatever they give:
- "Can you give me a real example?"
- "Walk me through what actually happened — what did you do or say?"
- "What did it cost you, or what did you feel?"

Don't grill them more than twice. The point is warmth, not interrogation.

**E. Save before moving on (every time, no exceptions).**

1. Write a question file at `02. Projects/Digital-Twin/questions/q{N}-{short-name}.md`:

   ```markdown
   ---
   question: {N}
   status: answered | skipped
   saved: {TODAY}
   ---

   # Question {N}
   {question text}

   ## Their answer
   {final answer}
   ```

2. Update `progress.md`: add 1 to `answered`, set `last_answered: {N}`, update `last_updated`.

If a save fails, STOP and tell them — don't carry on half-saved.

**F. Next question.** Loop to A with the next one.

If they say "stop": "Saved. Question {N} is locked. To pick up later, open Claude here and say 'continue' — I'll start at question {next}."

### The 15 Questions

1. Quick intro to start — your name, what you do, and who you're working to become.
2. Your story in a few chapters — including the hardest or most challenging stretch you've lived through, and what it taught you.
3. Forget your title for a second — who are you, in three sentences?
4. What are you chasing right now? Your real goals for this year.
5. Zoom out — what's the bigger vision? Paint your ideal day 10 years from now: who's there, what you're doing, how it feels.
6. What problem are you uniquely positioned to solve — and why you?
7. What comes easy to you but seems hard to most people?
8. What are 3 to 5 things you refuse to compromise on, even when it costs you?
9. What genuinely makes you angry or pisses you off? (What makes us angry says a lot about what we value.)
10. What's a belief you hold that most smart people would disagree with — and you'd still defend?
11. The 2 to 3 people you look up to most — who are they, why them, and what did each teach you?
12. What are your biggest fears and concerns right now?
13. What are you avoiding or putting off — something you know you should face but haven't?
14. When are you most alive? What conditions bring out your best work?
15. The frameworks or questions you reach for when a decision is hard — how do you actually think it through?

### When the questions are done

When all 15 are answered or skipped (or they say "build it now" early):
> "That's the 15. Now I'll pull it all together into your twin."

Update `progress.md`: `phase_2_questions: complete`, `phase_3_synthesis: in-progress`.

---

## PHASE 3 — Build the twin

Print:
> "Phase 3 — building your twin now.
>
> Reminder: this is the heavy thinking step. If you're on the $20/month plan, switch me to Sonnet first (it reads long things well). Tell me when you're ready."

### What to do

Read all 15 question files in `02. Projects/Digital-Twin/questions/`, plus any of their own notes already in the brain (their words only — ignore anything the AI said). Then write their twin into `03. Areas/Self/digital-twin/`, sorting what you learned into these folders:

- `1-voice/` — how they talk and write; signature phrases; tone
- `2-values/` — what they refuse to compromise on; what makes them angry; what they stand for
- `3-mental-models/` — how they think and decide; the frameworks they reach for; contrarian beliefs
- `4-goals-and-vision/` — what they're chasing now; the 10-year picture; their ideal day
- `5-story/` — origin, hardest chapters, who they are beyond the title, what they've learned
- `6-people-and-influences/` — who they look up to and what each taught them
- `7-fears-and-open-loops/` — fears and concerns; what they're avoiding; unresolved questions

**Write it in this order** (so if you're interrupted, what's done is still useful):

1. **Theme notes first.** Inside each folder, write one short note per clear theme. Each note: a plain-language summary of the pattern, where it shows up, and any exact phrases they used. Link related notes with `[[double brackets]]` — at least 2 links per note.

2. **A summary note per folder.** A `README.md` in each folder listing its theme notes and pointing to related themes in other folders.

3. **The master map LAST** — `03. Areas/Self/digital-twin/README.md`:

   ```markdown
   ---
   type: digital-twin
   built: {TODAY}
   based_on: {N} calibration answers{ + any imported data}
   ---

   # {Name} — Digital Twin

   > {One tight paragraph: who this person is, that the AI can read and instantly "get" them.}

   ## The big threads
   {3 to 5 patterns that show up across several areas — e.g. a value that drives their goals and their voice. This is what makes the twin feel like a person.}

   ## Map
   - [[1-voice/README|Voice]] — {one line}
   - [[2-values/README|Values]] — {one line}
   - [[3-mental-models/README|How they think]] — {one line}
   - [[4-goals-and-vision/README|Goals & vision]] — {one line}
   - [[5-story/README|Story]] — {one line}
   - [[6-people-and-influences/README|People who shaped them]] — {one line}
   - [[7-fears-and-open-loops/README|Fears & open loops]] — {one line}

   ## How to use this
   When I help with anything in their voice or about their direction, I read this first, then open the folder that fits. For the sharpest match, they can point me at a specific note: "write this in my voice, using [[1-voice/README]]."
   ```

**Two rules while writing:**
- Don't make things up. If a claim has no source in their answers or notes, drop it.
- Use their actual words wherever you can — especially for voice.

### When done

Check the master map and each folder README exist. Update `progress.md`: `phase_3_synthesis: complete`. Then:

> "Your twin is built, at `03. Areas/Self/digital-twin/`. Open the master map to see yourself through my eyes.
>
> Want to make it sharper? There's one optional step left — feeding me more of your real data. You can do it now or come back to it any time."

---

## PHASE 4 — Feed your brain (optional, recommended, do it any time)

Print:
> "Phase 4 — optional. Your twin already works. But if you give me your real history — old chats, notes, call recordings, documents — it gets a lot sharper, because it's grounded in how you actually talk and decide, not just today's answers.
>
> No pressure. Skip it, or do it now, or come back next week and say 'add this to my brain.' You don't need all of these — start with the one or two that hold the most of your thinking. Here's what you can give me, roughly most useful first:"

> 1. **Your ChatGPT history** — usually the richest: months of how you actually think. ChatGPT → Settings → Data Controls → Export data. You'll get an email with a link; download and unzip the `.zip`. The file that matters is `conversations.json`. Drop the folder into `01. Inbox/`.
> 2. **Your Claude history** — same idea from your Claude account: Settings → Privacy → Export data (wording may differ slightly). Drop the export into `01. Inbox/`.
> 3. **WhatsApp chats** — open a chat → Export Chat → Without Media → send it to yourself so the `.txt` lands on your computer → drop it in `01. Inbox/`. Do the chats that matter most: clients, your team, your own notes-to-self chat.
> 4. **Apple Notes** — use the free "Apple Notes Exporter" tool to turn your notes into text/markdown in bulk → drop the folder in `01. Inbox/`.
> 5. **Fathom call recordings** — open a call → Copy Transcript and Copy Summary → paste into a text file → drop in `01. Inbox/`.
> 6. **Notion pages** — in Notion, ... menu → Export → Markdown & CSV → unzip → drop in `01. Inbox/`.
> 7. **Business documents** — offers, frameworks, sales pages, SOPs, anything that holds your thinking (PDF, Word, markdown, text) → drop in `01. Inbox/`.

> "A few honest things: all of this stays on your computer — you're handing it to your own AI, not posting it anywhere. You don't have to be neat; I do the sorting. Start small — one source is enough to feel the difference, and every source you add makes the twin sharper. There's no rush and no finish line.
>
> Whenever you've added something, just say 'add this to my brain' and I'll sort it in and refresh your twin. If it's a big export and you're on the $20/month plan, tell me to use Sonnet for it."

### When they say any version of "add this to my brain"

(Treat any phrasing as the trigger — "add this to my brain," "add my ChatGPT history," "add these chats," and so on. They all mean: import what's new and refresh the twin.)

1. **Find what's new** in `01. Inbox/` (and `01. Inbox/agent-drops/`).

2. **For a chat export** (a folder with `conversations.json`): pull out the meaningful bits as small notes. The golden rule: only THEIR words are their words. When the AI wrote something, that's the AI's — even if they asked it to "write in my voice." Tag each note:
   - their words → `#source/user-statement`
   - something they clearly agreed with → `#source/user-belief`
   - the AI's words they didn't react to → `#source/model-statement` (kept for context, not used as their belief)

   Skip filler ("thanks," "ok"). One clear fact, opinion, or preference per note. Save notes to `04. Resources/AtomicNotes/{source}-{TODAY}/` (the folder the Strategy Engine made for this).

   **If this is a big export**, split the work across several helper sub-agents running at once to keep it fast, and give each the same rules above. (On the $20/month plan, use Sonnet for these.)

3. **For other files** (WhatsApp, Notes, Fathom, Notion, docs): read each, pull the meaningful bits into small notes the same way, and file them where they belong — about them → `03. Areas/Self/`, about a project → that project, about an ongoing area → that area.

4. **Watch for sensitive data.** If a file has passwords, full card numbers, ID numbers, or private medical details, don't copy those into notes — flag the file to them instead.

5. **Refresh the twin.** Re-run Phase 3's writing step, now with the richer notes folded in. Tell them what changed.

6. Update `progress.md`: `phase_4_feed_data: complete (last run {TODAY})`.

---

## Done

Print:
> "Your Self Engine is in.
>
> - Your twin lives at `03. Areas/Self/digital-twin/` — voice, values, how you think, your goals, story, the people who shaped you, and what you're wrestling with.
> - I read it whenever I help you, so what I write fits you.
> {if they fed data:} - Grounded in your real history, not just today's answers.
>
> Try me: 'Write a short post in my voice about {something you care about}, using my twin.' See if it sounds like you.
>
> Refresh this every 6-12 months — just run this file again and say 'continue.' Your AI workflows (the Systems Engine) come in a later session."

Update `progress.md`: `status: complete`.

---

## How resuming works (for you, Claude)

If they quit and come back later in a new session and say "continue":
1. The root `CLAUDE.md` points you to `02. Projects/Digital-Twin/progress.md`.
2. Read it, find the first step marked `pending` or `in-progress`, and carry on.
3. Tell them where you're picking up. They never re-paste anything.

---

## Safeguards

- Don't go past Phase 0 if the Second Brain isn't there.
- Save after every single question, and after each batch of imported notes. Never advance on half-saved state.
- All progress lives on disk (in `02. Projects/Digital-Twin/` and `03. Areas/Self/`), not in the chat — so it survives closing the app.
- Re-running is safe: it finds existing progress and offers to resume or refresh rather than wiping anything.
- Their words only count as their beliefs. The AI's words never do — even "write in my voice" output.
- Never invent answers or quotes. If there's no source, leave it out.
- If you're unsure what they mean, ask a short clarifying question rather than guessing.
- Phase 4 is optional. If they skip it, the twin still works.

---

That's the Self Engine. When they're ready, run Phase 0 and wait for "go."
