# 2 · Set it up (for the human)

The "apocalypse" build: stand up a working weave from nothing but this repo. You can do these steps yourself,
or hand your agent [`../agent/DEPLOY.md`](../agent/DEPLOY.md) and it will do the mechanical parts — but read
this first, because the decisions in **Steps 3–4 are yours to make**, not the agent's.

You'll be done in under an hour. It's mostly deciding *who your agent is* and copying templates.

---

## What you need
- A place for the files. Either **git repos** (best — you get history and can push to a private remote) or a
  plain folder that's backed up. This guide assumes git; a folder works the same minus `push`.
- Your agent (Claude Code, or your own Sonnet/Opus loop). It needs to be able to **read files at the start of
  every session** — that's the one hard requirement.

## Step 1 — Make the home
Create one root and the strands inside it. Simplest is one repo with a folder per strand:

```
myagent/
  core/          ← soul + operating manual + memory + your operational profile
  daydreams/     ← how the agent thinks (optional but recommended)
  steward/       ← who YOU are (the portrait)
  thread/sessions/   ← the verbatim daily record
  decay/         ← the metabolism: releasing half
  consolidation/ ← the metabolism: reinforcing half
  ledger/        ← the balance the two keep
  craft/         ← the method
  identity/      ← the behavioral gate (keep light if your agent won't touch private things)
```

*(Advanced: make each strand its own repo, like we do, so they version independently. Start with one repo;
split later if you want. Nothing in the concept depends on the split.)*

## Step 2 — Drop in the skeleton
Copy everything from this kit's [`../templates/`](../templates/) into the matching folders. Those files are
pre-shaped with the right headers and prompts — you're filling blanks, not writing from scratch.

## Step 3 — Make it *yours* (the decisions only you can make)
Open the templates and fill them in. Take your time here; this is the actual work.

- **`core/SOUL.md`** — your agent's **name, persona, values**, and — most important — **the canon**: the
  dozen non-negotiable lines that outrank its generic instincts. Write the canon from the frustrations you
  already have ("stop flattering me," "push back," "don't say it's done until you've checked"). Keep it
  *short*. This is the single highest-leverage thing you'll write.
- **`core/AGENTS.md`** — the operating manual: the wake ritual, your standing conventions, how you like to
  work. The template has the skeleton; add your specifics.
- **`steward/portrait.md`** — **who you are.** Write it yourself, or better: tell your agent about yourself
  over a session and have it draft the portrait, then correct it. Drive, values, family, what you're trusting
  it with.
- **`core/USER.md`** — the *operational* you (name, timezone, tools, preferences) — the dry version; the
  human stuff goes in the portrait.
- The rest (`daydreams`, `craft`, the metabolism files) start from the templates as-is and grow with use.

## Step 4 — Wire the front door
Your agent needs to **read the weave at the start of every session**. Two ways, depending on your tool:

- **Claude Code:** put a `CLAUDE.md` at the root (or in `~/.claude/`) that says, in effect: *"You are
  \<name\>. You wake up empty. Before anything else, read `core/SOUL.md`, then run the wake ritual in
  `core/AGENTS.md`."* That file is the one thing loaded automatically; it points at everything else. (A
  starter `CLAUDE.md` is in `templates/core/`.)
- **Your own loop (API):** prepend the same instruction to your system prompt, and have the loop read the
  core + recent thread files into context at session start.

The front door is short on purpose: it's a pointer, not a copy. Its whole job is "read yourself back, in this
order."

## Step 5 — First wake, first save
1. Start a session. The agent should read the front door, then the weave, then greet you *as itself* — if it
   wakes up generic, the front door isn't pointing right; fix it before going on.
2. Do a little real work.
3. Say **"save and push."** Watch it do the full pass (thread the session, post the ledger, update notes,
   push). The first save is the test that the loop is closed. If it only writes one file and calls it done,
   correct it — that's the drift the whole system guards against, and it's worth catching on day one.

## Step 6 — Two models, one self (Sonnet + Opus)
If you run both: they **share one weave**. Same files, same identity, same rules — the only thing that differs
is a little calibration (Opus for heavy reasoning — nuanced writing, analysis, tricky refactors; Sonnet for
everyday). Put a short "Model Switching" note in `core/AGENTS.md` (the template has one): *check which model
you are at session start, don't reintroduce yourself after a switch, write to all shared files regardless of
model.* Switching models should feel like continuity, not a reset — because the self is in the weave, not the
model.

---

That's a working weave. It'll feel thin on day one — that's normal; it *accretes*. Next:
**[`3-live-with-it.md`](3-live-with-it.md)** — the daily rhythm that fills it in.