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
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 a daily partner I now call Alice.
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, 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.