Silas Pruitt
89 lines
5.1 KiB
Markdown
89 lines
5.1 KiB
Markdown
# 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.
|