Build with Claude

Most Claude Code content is a walkthrough of the happy path. This is the other kind: specific things that broke while running Claude Code and agentic pipelines on this site's own infrastructure, why the failure was hard to see before it was fixed, and what actually changed. Each lesson names the mechanism, not just the moral.

Module 1

Cost & Infrastructure Economics

What it actually costs to run Claude Code day to day and on a schedule — and the specific changes that cut real spend without cutting quality.

1. 1 The Cheapest Way to Run Scheduled Claude Jobs Isn't the API A twice-daily job billed against the API drained an account balance for days. Moving it to a subscription runner fixed the bill and the blind spot it created. →
2. 2 The Env Var That Secretly Tripled Our AI Coding Bill We named our cost-control setting something that collided with Claude Code's own environment. Every automated run quietly inherited the most expensive option. →
3. 3 When Prompt Caching Costs You More Than It Saves Prompt caching is supposed to be free money. On calls spaced further apart than the cache actually lasts, it's a straight surcharge with nothing recouping it. →
4. 4 Why Your Spend Limit Doesn't Survive a Fresh CI Checkout A per-day API spend cap enforced in code still failed, because every scheduled run started from a clean checkout with no memory of prior spend. →
5. 5 How Five Free Workflows Added Up to a Real Bill Every automation looked cheap in isolation. Nobody added them up until the free tier ran out mid-month. Coming soon
6. 6 Stop Letting Your AI Agent Reroll From Scratch After Every Rejection A rejected draft doesn't need a whole new attempt — it needs one targeted fix using the reviewer's own notes. Coming soon

Module 2

Silent Failures

The absence of an error is not the same claim as "it worked." Seven incidents where a pipeline looked healthy while doing nothing, or the wrong thing.

1. 7 The Page That Loaded Fine and Showed Nothing Every page built, returned 200, and sat in the sitemap. Ten of them rendered zero content, and nothing but a manual look could tell. Coming soon
2. 8 The Eighteen Tests That Never Actually Ran Two test runners, two file conventions, and a flag that turns 'found nothing' into a pass. Eighteen tests guarding a publish gate had run zero times. Coming soon
3. 9 We Built a Drift Detector That Could Never Detect Drift One shell pipe put the counter in a subshell. The parent process never saw an increment, so the report always said the reassuring thing. Coming soon
4. 10 Your Alerts Need Their Own Alarm A deadman signal that fails open, a background task the runtime kills mid-flight, and drafts nothing was watching for — three ways an alert system can go quiet without telling you. Coming soon
5. 11 The Outage Where Every Health Check Said Everything Was Fine A retired model ID and a dead API key both failed the same way: silently, for days, while every automated check reported green. Coming soon
6. 12 A Feature Being Off Looks Exactly Like a Feature Being Broken A form guard that was deliberately disabled and one that was accidentally broken produced the identical warning — until the difference got written down. Coming soon
7. 13 One in Nine of Our Articles Was Cut Off Mid-Sentence Nobody checked why the model stopped generating. It turns out that's a field the API hands you for free, and ignoring it is expensive. Coming soon

Module 3

Credentials & Secrets

Agentic workflows change how credentials get created, checked, and leaked. Four incidents that weren't about a stolen key — they were about a check that lied.

1. 14 A Redaction Script Hid Every Secret Except One A regex that matched every variable name but one printed a live credential in full — and looked, at a glance, like it had worked. Coming soon
2. 15 Why Our Health Check Said a Working Key Was Dead One HTTP client returned 401 on a key that worked everywhere else. The false alarm was more dangerous than no check at all. Coming soon
3. 16 The Error Message That Sent Us In the Wrong Direction Throwing away a command's real output made a script confidently prescribe a fix that could not possibly have worked. Coming soon
4. 17 The Day Our Three Secret Stores Disagreed The same secret lived in three places. When they drifted, the failure looked like a mystery instead of the inevitability it was. Coming soon

Module 4

Running Claude Unattended

Scheduling agentic work and coordinating more than one agent surfaces failure modes interactive sessions never hit.

1. 18 Our Local Cron Jobs Kept Missing Their Runs A schedule tied to a laptop's uptime is not a schedule. Moving it to the cloud changed more than reliability. Coming soon
2. 19 The Scheduled Jobs Nobody Told the Scheduler About Nine task directories existed on disk. The thing that actually runs jobs only knew about seven of them. Coming soon
3. 20 A Green Checkmark Doesn't Mean the Work Got Done Exit code 0 means the session ended cleanly. It does not mean the thing you scheduled actually happened. Coming soon
4. 21 What Happens When Two AI Agents Race to Log the Same Event Two agents publishing at the same time registered the same event twice, and neither one could tell. Coming soon
5. 22 The Auto-Merge Setting That Doesn't Actually Protect Anything The setting was on. It gated nothing. Understanding why required reading how the feature actually decides when to wait. Coming soon

Module 5

Deploy, CI & Git

Shipping what an agent builds hits its own class of problems — most of them about ordering, not code.

1. 23 The Deploy Command That Broke Three Different Ways in One Month The same wrong deploy target failed differently each time, which made it look like three separate bugs instead of one repeated mistake. Coming soon
2. 24 A Squash Merge That Changed Nothing and Broke Everything Two commits that added a change and reverted it squashed into a no-op — except the earlier, still-broken version was what actually landed. Coming soon
3. 25 Our Security Scanner Got Cancelled by the Step Before It A routine, unrelated failure earlier in the job silently skipped the secret scan behind it — and the red X read as 'pipeline is being careful,' not 'the scan never ran.' Coming soon
4. 26 The Webhook That Was Faster Than Its Own Database A publish event triggered a rebuild in seconds — faster than the database it read from had finished catching up. Coming soon
5. 27 One Leftover File Broke Every CI Run for a Week A single tracked file, left over from an experiment, put every checkout into a state git's own tooling couldn't clean up after. Coming soon

Want this in your own stack

Running Claude Code in production is a program, not a prompt

If your team is scaling from individual Claude Code use to agentic pipelines running unattended, most of the failure modes above show up eventually. Happy to talk through what we've built.

Work with me →