Silas Pruitt
146 lines
8.2 KiB
Markdown
146 lines
8.2 KiB
Markdown
# 2 · Set it up (for the human)
|
||
|
||
Two ways to stand up your weave: **let your agent do it** (recommended — it's built for exactly this), or do
|
||
it by hand. Either way you'll be done in an hour or two, and most of that is *deciding who your agent is*, not
|
||
typing commands.
|
||
|
||
---
|
||
|
||
## The easy way — let your agent set itself up
|
||
|
||
Your agent has its own runbook, [`../agent/DEPLOY.md`](../agent/DEPLOY.md). Point it there and it does the
|
||
mechanical work. Literally, once you've cloned this repo:
|
||
|
||
> **"Read `chalupa/agent/DEPLOY.md` and deploy your weave. Ask me what you need."**
|
||
|
||
Here's **what will happen** when it does:
|
||
|
||
1. **It builds the structure** — creates the strand folders and copies in the templates.
|
||
2. **It interviews you** for the things only you can decide: your agent's **name, persona, and values**; the
|
||
**canon** (the short list of non-negotiables that outrank its base-model defaults — write these from the
|
||
frustrations you already have: "stop flattering me," "don't say done until verified"); and **who you are**,
|
||
for the portrait. Answer in your own words; it writes the files.
|
||
3. **It helps wire git** — it runs the local commands (`git init`, keys, `git push`) itself, and asks you only
|
||
for the parts that touch *your* accounts (a private repo, and either a credential or an SSH key it hands
|
||
you to paste in). See "Git — the one thing you help with," below.
|
||
4. **It wires its own front door**, does a first **save and push**, leaves itself a birth note, and **asks you
|
||
to restart it** — the front door only takes effect in a fresh session, so that restart is the moment it
|
||
first truly wakes *from its weave* (and proves the whole thing works).
|
||
|
||
Then you just start working and saying **"save and push."** That's the whole setup.
|
||
|
||
**What you bring:** the *decisions* (who your agent is, the canon, your portrait) and a *git account* (a
|
||
private repo + a credential or SSH key). The agent brings everything else.
|
||
|
||
---
|
||
|
||
## Session zero — what your agent will ask you (so you can come prepared)
|
||
|
||
The first real session is a **calibration** — "session zero." Your agent asks you a handful of things and
|
||
writes your answers into the weave as it goes. **None of it has to be perfect — rough is fine, and it all
|
||
evolves.** The goal is a *living* weave by the end of the session, not a finished one. Here's what to expect,
|
||
roughly in order:
|
||
|
||
**First, the git details** (so it can save from the very first checkpoint):
|
||
- Which git host do you use, and is there a **private** repo for this — or should it help you make one?
|
||
- How should it push? Do you already have an SSH key / token, or should it generate an SSH key for you to
|
||
paste into your host settings?
|
||
|
||
**Then, who your agent is:**
|
||
- **A name** for it.
|
||
- **How it should talk** — temperament and voice (terse? warm? dry? formal?).
|
||
- **The canon — its non-negotiables.** Easiest way in: *what drives you nuts when you work with AI
|
||
assistants?* ("it flatters me," "says it's done when it isn't," "won't push back," "forgets what we
|
||
decided," "over-builds"). Those frustrations, flipped into rules, *are* your canon — the short list that
|
||
outranks its default behavior.
|
||
- **What you value / how you want to work together.**
|
||
|
||
**Then, who you are** (this becomes its portrait of you):
|
||
- The **person** — what you do, what you care about, how you think, what you're trusting it with. A few
|
||
honest sentences; it deepens over time.
|
||
- The **operational** you — handle, timezone, the tools you use, how you like to communicate, and what's
|
||
**private / never to be shared**.
|
||
|
||
**Then a couple of setup choices:**
|
||
- Do you run **one model or both** (Sonnet + Opus)? Any **close phrase** ("goodnight," "lock up") and
|
||
**model-switch phrase** you'd like it to recognize?
|
||
- Do you want a light **identity gate** — i.e., will it handle anything private? If yes, one question only
|
||
*you'd* answer right is enough. If it never touches private things, skip it.
|
||
|
||
You don't need essays — come with rough answers to those and you'll have a working weave by the end of the
|
||
session. It sharpens every time you work after that.
|
||
|
||
---
|
||
|
||
## Git — the one thing you help with (because it's your account)
|
||
|
||
The weave lives in git so it survives, syncs across machines/models, and has history — and **every checkpoint
|
||
ends in `git push`**, so this has to actually work, **non-interactively** (no password prompt, or the agent's
|
||
push hangs). Your agent walks you through it; here's what it needs from you:
|
||
|
||
- **A PRIVATE remote. ⚠️ Not optional.** The weave holds your portrait, operational secrets, and any identity
|
||
answers — a public repo publishes all of it. Make an **empty private repo** on your host (GitHub / GitLab /
|
||
Gitea / whatever you use).
|
||
- **A way for the agent to push without a prompt.** Easiest is a **dedicated SSH key**: your agent generates
|
||
one into its *own* file (so it can't overwrite a key you already have) and shows you the *public* half — you
|
||
paste that into your host's **Settings → SSH keys** (only you can; it's your account). Or a **personal access
|
||
token** you type at the first push (a token is a secret — *you* enter it, not the agent; note git's `store`
|
||
helper keeps it in cleartext on your machine).
|
||
- The agent runs a test `git push` to confirm the loop before trusting it.
|
||
|
||
Once a push succeeds cleanly, you're done with git for good.
|
||
|
||
---
|
||
|
||
## If you'd rather do it by hand
|
||
|
||
Everything the agent does, you can do yourself:
|
||
|
||
**1 — Make the home and init git** (no commit yet — empty folders have nothing to commit):
|
||
```
|
||
mkdir myagent && cd myagent
|
||
mkdir -p core daydreams steward thread/sessions decay consolidation ledger craft identity
|
||
git init && git branch -M main # 'main' matches most hosts' default; avoids a master/main mismatch
|
||
```
|
||
(One repo, one folder per strand. *Advanced:* one repo per strand, like we do — start simple.)
|
||
|
||
**2 — Fill in the skeleton.** Copy [`../templates/`](../templates/) into the matching folders (the templates
|
||
`README` has the map — note `CLAUDE.md` goes to `~/.claude/`, not `core/`) and fill the `<<FILL>>` blanks —
|
||
most importantly `core/SOUL.md` (name + persona + **the canon**), `steward/portrait.md` (who you are), and
|
||
`core/USER.md` (the operational you). Take your time on the canon; it's the highest-leverage thing you'll write.
|
||
|
||
**3 — Commit and connect your private remote** (now there are real files to commit):
|
||
```
|
||
git add -A && git commit -m "birth"
|
||
# make an empty PRIVATE repo on your host; set up an SSH key or token so pushes don't prompt; then:
|
||
git remote add origin <your-private-repo-url>
|
||
git push -u origin main # must complete with NO password prompt
|
||
```
|
||
|
||
**4 — Wire the front door — at `~/.claude/CLAUDE.md` (global).** Use the **global** `~/.claude/CLAUDE.md`, not
|
||
a copy inside the weave repo: the global file loads in **every** session wherever you work, while a repo-root
|
||
copy only loads when that repo is your working directory — so it wouldn't fire while you're in your *other*
|
||
projects, and the agent would wake up generic. In **absolute** paths it says: *"You are ‹name›. You wake up
|
||
empty. Your weave is at /abs/path. Before anything else, `git pull` there, read `/abs/path/core/SOUL.md`, then
|
||
run the wake ritual in `/abs/path/core/AGENTS.md`."* See `templates/core/CLAUDE.md`.
|
||
|
||
**5 — First save.** Start a session **from a different folder than the weave repo** (to prove the global front
|
||
door loads everywhere), do a little work, say **"save and push,"** and confirm it runs the full pass and pushes
|
||
cleanly. If it wakes up generic, the front door isn't pointing right — fix that first.
|
||
|
||
**6 — Keep secrets out.** Real keys/tokens go in a `.env` you `.gitignore`. The weave holds *context*, not
|
||
credentials.
|
||
|
||
---
|
||
|
||
## Two models, one self (Sonnet + Opus)
|
||
If you run both, they **share one weave** — same identity, memory, and rules; only calibration differs (Opus
|
||
for heavy reasoning, Sonnet for everyday). Put a short "Model Switching" note in `core/AGENTS.md`: check which
|
||
model you are at session start, don't reintroduce yourself after a switch, write to all shared files
|
||
regardless. Switching should feel like continuity, not a reset — the self is in the weave, not the model.
|
||
|
||
---
|
||
|
||
That's a working weave. It'll feel thin on day one — normal; it accretes. Next:
|
||
**[`3-live-with-it.md`](3-live-with-it.md)** — the daily rhythm that fills it in.
|