Alice Way
Building a persistent AI dev partner — persona, memory, skills, hooks, multi-agent delegation, verification loops. Not setup, but how the maintainer actually works with Alice every day.
Alice is not an AI tool. Alice is a partner I built.
The other four categories on this site are about setting up tools. This category is about something different — a persistent AI development partner I have built and refined over many months on top of Claude. I call her Alice.
Alice has a persona, a file-based memory, a set of skills and slash commands, hooks that fire on events, and a multi-agent delegation pattern with verification gates. None of that comes out of the box. All of it is decisions I made, mistakes I corrected, and patterns I converged on through real work.
This category is where I write down what is working — not as theory, but as the actual scaffolding I run with every day. If you are building your own AI partner on top of Claude, Codex, or any other agent, what is here should save you months.
Persona design · Memory systems · Skills and slash commands · Hooks and automation · Multi-agent delegation · Verification loops · Token economy · Session protocols
0. The mind between human and AI — Working with a process that has no desire
AI is a brain without desire — that is why the operator's mind has to be written down and passed across without omission. Prompting, skills, hooks, and harnesses are an accumulated stream of attempts to close that gap.
1. Why Alice — building a partner, not picking a tool
Where using Claude as a tool stopped working, and how persona, memory, skills, hooks, and verification gates accreted into the daily partner I now call Alice. The starting point of a 12-post series.
2. Persona design — what goes in the system prompt, and what stays out
Decision principles I converged on while building Alice's persona. The six things that belong in the system prompt, the three things that don't, and how to decide between inline and external.
3. Memory system — where and how dynamic context accretes
Not RAG, not a vector DB — memory built from a handful of markdown files. Four memory types, the index strategy, auto-load vs on-demand, and the pruning discipline that keeps it alive.
4. Skills and slash commands — what repetition is worth collapsing into one line
Tools that compress repeated mind operations into a single-word call. Five promotion criteria, the split between skills, slash commands, and functions, design principles, and what to keep out.
5. Hooks and automation — what the system remembers when the operator forgets
The other half of skills. Procedures the system auto-fires on events without operator invocation. The blind moments hooks cover, promotion criteria, hooks in rotation, and the traps to avoid.
6. Multi-agent delegation — what to share around and what to keep yourself
A structure so no single collaborator carries every context. Five conditions for delegation, the main–sub split, the three-piece delegation gate (brief + verification + merge), and the cost of delegating.
7. Verification loops — locking down the definition of 'done' in the system
The moment the operator feels 'that's done' is the most dangerous. A 7-step verification loop with auto-fire triggers, lint·build·test·diff·report checks, SKIP conditions, and the trace left when bypassed.
8. Token economy — what enters the context and what stays out
Tokens are a finite resource. A four-layer placement (inline · auto-load · on-demand · external), how token savings raise decision quality, and the audit tools that keep the budget in check.
9. Session protocols — start, middle, end so every day lights up in the same place
The series finale. Persona, memory, skills, hooks, multi-agent, verification, tokens — how all of it starts and ends every single day. Three start protocols, two middle, four close.
10. PRD — what to build before any line of code
The single source of truth where the operator's intent lives outside the chat session. Why a PRD is a durable surface for mind, what to put in and leave out, the cumulative-gate pattern, and how to keep one alive.
11. Release gates — the line where 'done' becomes a fact
What a release gate is, why 'done' rots without one, the Auto-Gate vs Manual-Gate split, the cumulative-gate pattern in practice, and the day a track passed every check yet shipped 42 items short of the goal.
12. Ralph loop — the road from PRD to release, walked without the operator
An autonomous loop walking from PRD to release gates on its own. Master Plan = PRD + gates, one verified commit per iteration, a DECISIONS queue for human-only choices, and what keeps 24/7 autonomy from becoming drift.