The Memory Myth
What you might think: "AI remembers our conversations and learns about me over time."
What's actually happening: Every time you start a new chat, you're talking to someone who has never met you. LLMs (Large Language Models) like Claude, GPT, and Gemini don't have persistent memory. They read your message, generate a response, and forget everything.
Why this matters: If you spent 2 hours explaining your project yesterday, today's AI has no idea. You're starting from zero.
Files Are Your Playbook
Here's the trick: AI can't remember, but your playbook can.
When you write context into a file:
- AI reads it at the start of each session
- It knows what you're building, what you've decided, where you left off
- Re-explaining is gone, there's now a natural continuation
The playbook concept. Your markdown files aren't a one-time handoff. They're a living strategy document. Write your decisions once, and every future session reads them. Write your constraints once, and AI never violates them. The playbook grows with your project.
| Without Files | With Files |
|---|---|
| "So what are we building?" | "I see we're building X. Last session you completed Y. Ready to tackle Z?" |
| You re-explain every session | You pick up where you left off |
| AI makes wrong assumptions | AI follows your documented decisions |
The Hallucination Problem
What you might think: "AI sometimes makes things up, but I can catch it."
What's actually happening: LLMs generate text probabilistically. Without ground truth, they'll confidently invent facts, make assumptions, or misremember earlier context.
Common Hallucinations
| Type | Example | Why It Happens |
|---|---|---|
| False memory | "As we discussed last week..." (you never discussed it) | No actual memory, fills gaps with plausible text |
| Invented facts | "Your API uses OAuth 2.1" (you never mentioned auth) | Guesses common patterns |
| Assumed context | Changes code you didn't ask to change | Assumes "improvements" are wanted |
| Phantom features | "The login system already has password reset" (it doesn't) | Confabulates from similar projects |
Files as Ground Truth
The solution: Files are the single source of truth that prevents hallucinations.
| Without Files | With Files |
|---|---|
| AI guesses your tech stack | CLAUDE.md: "Tech: Next.js 14, Supabase, Tailwind" |
| AI assumes features exist | PRFAQ.md: "What we're building, what's done, what's not" |
| AI invents past decisions | DECISIONS.md: "DEC-001: Why we chose X over Y" |
| AI contradicts itself | CONSTRAINTS.md: "Never use library X (reason)" |
Building Your Ground Truth System
Start Small
You don't need 50KB of documentation. Start with three essentials:
The 4 Habits: These three files map to the protocol's core habits. Plan in markdown (TODO.md), protect decisions (CONSTRAINTS.md), and align AI with your goals (CLAUDE.md). The fourth habit, measure compound, comes from PROGRESS.md when you're ready to grow.
1. CLAUDE.md / Technical Facts Habit 3: Alignment
## Tech Stack - [Exact versions and tools] ## Architecture - [How things connect] ## Current State - [What exists, what doesn't]
2. TODO.md / What's Next Habit 1: Markdown Planning
## Active - [ ] Feature X - AC: Specific, testable criteria
3. CONSTRAINTS.md / Never Do This Habit 2: Protect Decisions
## Rejected Approaches - Don't use library X (reason: Y) - Don't implement feature Z (decided: DEC-015)
Pro tip: Number your sessions in PROGRESS.md. Session #1, set up protocol files. Session #2, first feature with context. Session #3, AI referenced a decision from Session 1 without being asked. That last one is the compound moment. When you can see the numbers growing, compounding feels real.
Grow Incrementally
Each time AI hallucinates:
- Catch it
- Document the truth in the relevant file
- Next session reads the correction
- Same mistake won't repeat
Token Economics
What Are Tokens?
Tokens are how AI measures text. Roughly:
- 1 token ≈ 4 characters (English)
- 1 token ≈ 3/4 of a word
- This sentence is about 10 tokens
Every interaction costs tokens:
- Input tokens: What you send (your message + context files)
- Output tokens: What AI generates back
Context Budget
Think of AI like a person with a whiteboard. The whiteboard has limited space.
Everything must fit on the whiteboard:
- Your current message
- The files AI is reading (CLAUDE.md, TODO.md, etc.)
- The conversation so far
- Room for AI's response
If you fill the whiteboard with context, there's less room for AI to think and respond well.
The protocol's solution: Different roles load different amounts of context. Architect scope loads full context (~15%) for planning. Builder scope loads lean context (~5%) for focused implementation.
The Atomic Interaction Model
Every productive AI interaction follows the same five phases, whether you're delegating a task, building software together, or automating a workflow.
Each cycle's RECORD makes the next cycle's LOAD richer.
Which Protocol Is For You?
Ask yourself: "What's AI's role in my work?"
AI works FOR you → uno (Operate)
You define WHAT needs doing. AI handles HOW.
Examples: Trip planning, documentation, research, tracking projects
AI works WITH you → duo (Construct)
You and AI build together. AI designs, you approve. AI implements, you guide.
Examples: Software projects, product builds, anything with code
AI works AMONG systems → tre (Automate)
AI operates between your tools, with quality gates and human approval points.
Examples: Ticket triage, deployment checks, automated workflows (coming soon)
Glossary
| Term | Meaning |
|---|---|
| LLM | Large Language Model. The AI that powers tools like Claude, GPT, Gemini. |
| Context | Everything AI can "see". Your message, files, conversation history. |
| Token | Unit of text (~4 characters). Bigger context = more tokens = more cost |
| Handoff | Structured transfer of context, like a shift change briefing |
| Session | One atomic cycle of work with AI |
| AC | Acceptance Criteria. How you know a task is actually done. |