Why I built albinogeek.com

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.

What I do day-to-day

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 gap I kept hitting

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.

Why pay-once, not a course or retainer

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.

For the Playbook: $29. You get a document that covers the five most expensive production mistakes in MCP and Claude Code work, with the actual fixes, not the conceptual explanation. If you read it in 45 minutes and find one thing that saves you an afternoon, it paid for itself before lunch.

For the Power Pack: $129. Everything in the Playbook plus working code templates — a multi-agent hook stack, a file-ownership skill, a Polar webhook handler, the patterns I actually use. You clone them, adapt them, you're moving in under an hour.

For a time block: $500 to $2,500 depending on length. You show up with your actual stack and your actual problem. I look at your code. We work through it together. You leave with a fix, not a recommendation.

All lump-sum. No upsell after the initial purchase. No "upgrade to premium tier." The Playbook doesn't exist to funnel you into the Power Pack — it exists because the content is worth $29 on its own.

The bet

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 is that developers who are past the tutorial phase — who have a real project, a real deadline, and a specific problem — will pay a small amount for a document that's written from that perspective. And that some of them will pay more for a few hours of focused work with someone who has already been through the hard parts.

If that describes you, the Playbook is the place to start. It's $29. Read it this week, or ask for a refund. Either outcome is fine.

If you're past the Playbook and you have a specific problem in front of you, book a time block. I'll tell you if I'm the right person for it.