Claude Code doesn't get worse — your context does.
Stop collecting AI advice. Start shipping with it.
Install it once. Every session inherits it. A playbook isn't a course you watch — it's an artifact you run, and what it leaves behind is a working setup: CLAUDE.md, rules, agents/, skills/, hooks, and a verification loop. First edition: for Claude Code.
Free quickstart playbook included · No credit card required
What gets installed
v1.1.0 · updated 12 Jul 2026
Built by walking the playbook it sells — every step in this product has a commit behind it. See the release history →
The problem
It's not the model. It's your setup.
Nobody ships a bad session on purpose. It happens the same way every time: the window fills with stale junk, the rules you explained never made it to disk, and nothing in the loop checks the work before you do.
- Context rot
- You start sharp. Two hours in, the answers get vaguer and start contradicting code it wrote itself an hour ago.
- Compaction · AI amnesia
- The window fills, it summarizes, and the decision you made this morning is gone. You're the model's memory now.
- The doom loop
- Fix → break → fix again. It undoes its own changes, and you end up exactly where you started.
- Token burn
- One session stuck in a loop can drain your daily budget in minutes, and you have nothing to show for it.
- Babysitting
- You read every diff so closely that writing it yourself would have been faster.
- Codebase drift
- Every session moves the codebase a little further from the shape you designed, and nobody is watching the shape.
Not the model getting lobotomized. A session with no memory, no rules and no verification loop.
The 70% problem: the demo is easy. The last 30% is your job again.
That last stretch is where slop shows up — code that compiles, passes tests, and quietly rots the codebase from the inside. None of it means the model got worse. It means your setup decayed. Setup is the part you can actually fix, and it's the part nobody hands you.
The method
A playbook is something you install.
Not a course, not a PDF, not a folder of prompts. One opinionated path through a real build — and a setup that is still there when you're done with it.
Courses measure hours watched. A playbook measures things shipped. Starting one turns it into a project in your workspace: every step has a status, your notes live where you work, and the order is one somebody else already argued about — what to do first, what to skip, what to ignore.
What accumulates while you walk it is your setup DNA — CLAUDE.md, rules, agents/, skills/, hooks and a verification loop — the files a fresh session reads before it touches your code. Install them once and every session inherits them, instead of mutating into chaos while you re-explain the same decisions.
The setup contract
You write the left column once, into real files in your repo. Every session inherits the right column before it touches your code.
The setup is versioned, so it stays current.
When a playbook gets a new release, you pull the changed steps into your project. Only the changed part of the sequence moves — your status, your notes and your work stay exactly where they were.
01
Plan
Spec the build before the build. The two questions that kill most projects get answered on day one, with an AI critique pass on your own plan.
02
Setup
CLAUDE.md, rules, permissions, hooks, agents and skills — written to disk, in the order that makes each one work. This is the part that stops the re-explaining.
03
Build
The MVP line, three build workflows, and verification loops that keep an agent's speed without inheriting an agent's mess.
Install, don't study
A sequence you run, not a doc you read.
One step at a time, in order, with the decisions already made. The journey rail shows where you are, chapter checkpoints show what's behind you, and when you come back on Thursday it reopens exactly where you stopped. By the end the setup isn't described to you — it's on your machine.
- Per-section status, notes, and priorities
- Chapter checkpoints with a mini-board per phase
- Resume bookmark — you pick up mid-sequence, not from zero
Tracked like real work
Your progress lives outside the chat window.
Every playbook run has its own board — drag sections through statuses, flag what's blocked, filter by phase. Nothing you decided is trapped in a session that compacts away at the wrong moment. The last 30% stops being a vague dread and becomes a column you can see.
- Five statuses, drag and drop
- Blockers and priorities per section
- Progress rolls up to the project automatically
Versioned updates
When Claude Code changes, you get the diff.
Claude Code ships constantly, and a setup nobody maintains quietly rots. When a release changes the right way to do something, the playbook changes with it — and you see a per-section diff, old next to new, and pull only what you want. Your notes, your statuses, and your own edits stay exactly where they are.
- Old → new preview before anything is applied
- Apply one section or all of them — your call
- Every release logged in the public changelog
What an update looks like
Two parts of the setup moved — your CLAUDE.md and your hooks. The rest of the sequence is untouched, and so is everything you wrote.
The obvious question
Why not just ask AI?
Ask, and you get the advice — confident, plausible, slightly different next Tuesday, and gone when the session ends. A playbook is the other half: the order to do things in, the files it writes, and the check that proves the step actually worked.
Claude Code is the best tool we've used — that's the whole reason this exists. Reproducing advice was never the hard part. Getting the same good result on session 40 as on session 1 is, and that comes from the setup you leave behind: CLAUDE.md, rules, agents/, hooks, verification. Install it once; every session after inherits it.
Inside the flagship
The whole sequence, listed. Nothing behind a curtain.
3 phases · 25 sections · 31 deep-dive subsections · v1.1.0
01Phase 1 — PLAN (15–40 minutes)
5 sections- 0.1How to use this playbookFree
- 1.1Brainstorm (10 minutes)10 min
- 1.2Answer the 2 critical questions (5 minutes)5 min
- 1.3Use AI to improve your plan (5–15 minutes)5 min
- 1.4Create the Project Spec (10 minutes)10 min
02Phase 2 — SETUP (30–90 minutes)
16 sections- 2.1Step 1 — Create a GitHub repo (recommended)
- 2.1ATrack your feature list with GitHub Issues + a Project board (recommended)
- 2.2Step 2 — Environment variables
- 2.3Step 3 — Create `claude.md` (project memory)
- 2.4Step 4 — Automated documentation (recommended)
- 2.5Step 5 — Plugins (optional but powerful)
- 2.6Step 6 — MCP servers (optional; pick what helps)
- 2.7Step 7 — Slash commands + subagents (recommended)
- 2.7A🧠 Meta-prompting workflow (recommended for complex tasks)
- 2.7B🧠 Claude Skills (optional, high-leverage for repeatable workflows)
- 2.11Instructions
- 2.12Output format
- 2.13Success criteria
- 2.7C🧠 Agent Teams (experimental — powerful for multi-file implementation)
- 2.8Bonus — Pre-configure permissions (recommended)
- 2.9Bonus — Hooks (advanced automation)
03Phase 3 — BUILD (MVP → milestones)
4 sections- 3.1Build the MVP first
- 3.2Use one of the 3 build workflows
- 3.3Build-phase tips that prevent pain
- 3.4Quick checklist (copy/paste)
Every section is listed because there's nothing to hide: the value isn't secret information — it's the sequence, the opinions baked into it, and the upkeep. You finish with a configured Claude Code setup — CLAUDE.md, rules, agents/, hooks, a verification loop — and a project you actually shipped. No certificate.
No account needed.
A note from the founder
Hey — I'm the founder, a senior software engineer. I built this platform — the auth, the editor, the board, this page — by running the playbook it sells. Not as a marketing stunt: it's genuinely how I work, and every playbook here is that setup written down and kept current.
I got tired of the same loop everyone else is in: a great first session, then re-explaining the same decisions on Monday, then watching a fix break the thing I fixed yesterday. The fix wasn't a better prompt. It was a setup that every new session inherits — and it takes a few hours to install properly, once.
When Claude Code changes — and it changes weekly — updating the playbook is my job, not yours. Every change ships as a versioned release you can read in the changelog and pull into your project without losing your notes.
If you finish a playbook and still didn't ship, I want to know why — that's what the free unblock call is for.
— the founder
Fit check
Who this is for — and who it isn't.
This is for you if
- You have a real project waiting and a bookmarks folder that proves you've been “about to start” for months.
- You build with Claude Code most days and you're tired of babysitting it — re-explaining the same architecture, watching it repeat a mistake you corrected three sessions ago.
- You're a founder or PM technical enough to build with AI, but done assembling a workflow out of forty tabs and someone's thread.
- You want the setup — CLAUDE.md, rules, agents, hooks, verification — installed properly once, not rebuilt from scratch every time the tools move.
This is not for you if
- You want something to watch. There's no video and no certificate; a playbook only pays off if you actually run it.
- You're collecting AI material for later. This is for the project you keep not starting — filing it on the pile is the exact behaviour it's meant to break.
- You want the model to do all of it. This makes your sessions reproducible; it doesn't take you out of the loop, and it won't do the last 30% for you.
- Your team bans AI-assisted development. Nothing here helps until that changes.
Pricing
Buy the one playbook, or subscribe to all of them.
Priced as what it is: a setup you install once. One payment for the flagship and every v1.x update after it — or a subscription if you want everything we publish.
Claude Code Playbook
$49one-time
- The full playbook as a runnable project
- Ends with a configured setup: CLAUDE.md, rules, agents/, hooks, verification
- Lifetime v1.x updates — every minor release, forever
- Walkthrough, board, notes, and export included
- Downloadable resources
Last updated 12 Jul 2026 · v1.1.0
Start free todayCheckout opens soon. Founding price: $49.
All-Access
$12per month
- Every playbook, current and future editions
- All updates while subscribed — including major versions
- Cancel anytime
For teams
Teams & consulting
For teams that want the same setup on every machine. Team pack: $490 for 5 seats plus a live workshop. Consulting engagements from $1,500.
Book a callThe inverse guarantee
Ran the whole playbook and still didn't ship? Book a free 30-minute unblock call and we'll work out what's in the way. We'd rather get you shipped than keep the $49.
One call per finished playbook — it's an offer, not a help desk.
Your $49 covers v1 of the playbook — and every v1.x update we ship, forever. Keeping it current as Claude Code changes is the work you're paying for. If a v2 ever exists it's a separate, optional purchase; no subscription hiding inside a “lifetime” promise.
FAQ
Due diligence, answered.
- Why pay for this when I can just ask Claude?
- Ask it and you'll get the advice — good advice, phrased slightly differently every time, and gone when the session ends. What you can't ask for is the order to do things in, an opinion about what to skip, the verification step that proves it actually worked, or a note when this month's release changes the answer. That's the setup, and the setup is the part you keep.
- Will this be stale next month?
- Assume the tools will move — that's why the playbook is versioned. Claude Code ships constantly, and keeping the playbook current is the product, not a favour. Every change lands as a numbered release you can read in the changelog and pull into your project section by section, old next to new, without touching your notes or your progress. The “last updated” date on this page is live data, not a marketing line.
- I already have a CLAUDE.md. What does this add?
- You're ahead of most people, and nothing here throws it away. The playbook tells you what belongs in that file and what quietly bloats your context, then adds the parts most setups are missing: rules,
agents/, hooks, and a verification loop so a step that didn't really work gets caught instead of shipped. If your setup already has all of that, read the free section, confirm it, and buy nothing. - Will this burn more tokens, or fewer?
- Fewer, if the setup does its job. Most of the burn in a long session is re-explaining things the model already had, re-reading files it already saw, and doom loops where a fix breaks the previous fix. The whole angle here is a setup that stays cheap and consistent: tighter context per session and a verification step so you stop paying twice for the same work. We don't publish a percentage — anyone quoting one hasn't seen your codebase.
- What exactly does “lifetime v1.x updates” mean?
- When you buy the playbook, you own version 1 and every 1.x release we ever ship — improvements, new sections, tool-change updates — at no extra cost, for as long as the platform exists. If a v2 ever exists, it's a separate, optional purchase, and your v1.x access never expires.
- Is this a course?
- No. There's no video to watch and no certificate at the end. A playbook is an opinionated build sequence that runs as a trackable project — you install a working setup and ship a real project, or it wasn't worth writing.
- Is this a subscription? Do I lose access?
- The $49 playbook is a one-time purchase — no recurring charge, access doesn't expire. All-Access is a subscription for people who want every playbook and future editions; cancel anytime.
- Can I buy it right now?
- Not yet — checkout isn't open. Accounts are free today, the quickstart playbook and the whole project tracker are live, and the founding price is $49 when checkout ships. No countdown, no waitlist theatre.
- How much experience do I need?
- You should be comfortable running commands in a terminal and want to build something real. Sections give beginners the context and experienced developers the shortcut — start from zero or skip ahead; skipping is a tracked, first-class move.
- How long does it take?
- Every section shows an honest time estimate before you start it, and the totals are on the sequence above. Most people run it alongside a real project rather than in one sitting — that's what the progress tracking is for.
- What do I get for free?
- A full quickstart playbook and the project tracker itself, free, no card. The free tier is a working product, not a teaser — upgrade only if you want the flagship.
- What's the refund policy?
- 30 days, money back. One honest condition: heavy use voids it — if you've exported a playbook, downloaded its resources, or completed most of it, we'll assume it worked. Full terms are one page, in plain language.
- Can I expense this for my team?
- Yes — you'll get a proper invoice. For 5+ people the team pack ($490) includes a live workshop; reply to your receipt or book a call and we'll set it up.
- Does this only work with Claude Code?
- This edition is written and verified for Claude Code — real commands, real config files, not tool-agnostic hand-waving. The method carries over, and further editions are on the roadmap.
Something we didn't answer? Email [email protected] — a human reads it.
Start here
Install it once. Every session inherits it.
Start with the free quickstart playbook: a working CLAUDE.md, the rules that stop the drift, and a verification step — installed on your machine, not filed on the pile.
Start free todayFree quickstart · no card · checkout isn't open yet
CLAUDE.md · rules · agents · skills · hooks · MCP · verification — the setup a playbook leaves behind.