Loading page…

Most days I'm writing TypeScript. Not in a tutorial environment — in a production stack that processes real webhooks, routes agent output to real inboxes, and breaks in ways I have to fix before my next meeting. I've been building with Claude Code and MCP servers for long enough that I now have a mental model of where they fail, why they fail, and how to recover quickly.
That daily practice is the thing I'm selling here. Not the idea of it. The actual thing.
My work at a second company involves production multi-agent orchestration. That means CLAUDE.md files that actually govern agent behavior, hooks that intercept tool calls before they hit the wrong API, worktrees that let 25 concurrent agents work without thrashing each other's branches. The stack is live. It has users. It breaks and I fix it.
The volume matters. I've debugged more MCP stdout corruption issues in the last six months than most developers will see in two years. I've written production hook stacks, seen them fail under rate limits, and rearchitected them. I've watched a multi-agent pipeline eat itself because two agents shared a branch and neither knew about the other's staged changes. I've been through the whole list.
That repetition is what turns "I know this works" into "I know why it works, and here's the two-line fix when it doesn't."
The tooling has good documentation for getting started. Anthropic's Claude Code docs cover installation, slash commands, tool permissions. The MCP spec covers the wire protocol. These are accurate and well-maintained.
They don't tell you what happens when your MCP server's transitive dependency prints a deprecation warning to stdout, corrupting every JSON-RPC frame downstream. They don't tell you how to structure a file-ownership matrix that prevents two parallel agents from modifying the same file. They don't tell you when to reach for a hook versus a CLAUDE.md rule, or how to write a skill that survives being called from a subagent context.
That knowledge exists. It's just distributed across GitHub issue threads, Discord messages, and the hard-won experience of people who have shipped production agent systems. Nobody has assembled it into a usable document you can sit down with.
I kept seeing developers — competent ones — stuck on things I'd already worked through. Not stuck because they weren't capable, but because the production playbook didn't exist yet.
So I wrote it.
I thought carefully about format before shipping anything.
A course would mean recording videos, maintaining a curriculum as the tooling changes, supporting students through their individual setups. The tooling is moving fast. A course recorded in Q1 would be partially stale by Q3. I don't want to sell stale.
A cohort solves the staleness problem but creates a scheduling problem. You wait for the next cohort. You learn alongside people at different starting points. You need the information now. Cohorts don't serve that.
A retainer means I'm on the hook for your problems every month, indefinitely, whether or not the problem is one I'm the right person to solve. I've seen what that does to how you work. You stop optimizing for the outcome and start optimizing for the relationship. You give advice that keeps you in the room. I don't want to do that.
The pay-once model is honest. You pay for a thing. You get the thing. If the thing doesn't help you, you say so within the first week and I refund it, no questions. No SLA, no monthly invoice, no performance of ongoing value.
The AI Field Guide is $39 USD: how to tell an assistant what you mean, in plain language. The Skills & Rules Starter Kit is $149 USD: fill-in rules files and six skills to make your own. If you work in a terminal, the Builder Edition is $249 USD: the Starter Kit plus the developer chapters and a template repository.
If you would rather not do it alone, Guided Setup is $450 USD for two hours one to one, and the Done-For-You packages are $1,250 and $2,500 USD for a fixed list of deliverables. You leave with a working setup, not a recommendation.
All lump-sum. No "upgrade to premium tier." Each product has to be worth its price on its own.
There are a lot of people writing Claude Code tutorials right now. Most of them are one-line-of-code-in-a-browser-window explanations of features that are already in the docs.
What doesn't exist is the production record. The decisions that look obvious in hindsight but cost you three hours the first time you hit them. The architectural choices that matter at scale but are invisible at toy-project scale.
My bet was that developers past the tutorial phase would pay a small amount for a document written from that perspective. What I learned after writing it is that the same habits help anyone who uses an assistant every day, code or no code. Frontier models now drive APIs and CLIs directly, so wiring tools together matters less than it did. Telling the assistant what you mean matters more: rules it follows every time, skills it can reuse, and prompts that leave it nothing to guess.
If that sounds useful, the free primer is the place to start. If you have a specific problem in front of you, contact me. I'll tell you if I'm the right person for it.
The AI Field Guide teaches the whole method in plain language: how assistants read you, how to ask, how to check the answer, and how to write rules and skills. For Claude, ChatGPT, Cursor, and Codex.