spec-driven development, explained
spec-driven development means writing the spec - requirements, design, tasks - and correcting it before agents write code. what it is, where it helps, and its honest limits.
why 20 Claude Code instances break down (and what to do)
scaling Claude Code from 5 to 20 parallel agents crosses a threshold where qualitatively different failure modes appear — rate limits, supervision collapse, context cascade failures. what breaks, and what to do instead.
compound engineering with Claude Code: the loop, and the step everyone skips
Compound engineering — each task makes the next one easier — is the real shift in AI coding. Here's the loop, why the 'compound' step is the one everyone skips, and how to make it structural.
keeping context and decisions consistent across parallel AI agents
run several Claude Code agents at once and they drift — each has its own context window, none remembers what the others decided. what actually needs to be shared, and how teams keep parallel agents coherent.
AI didn't kill software craft. it moved it.
the worry that AI killed craftsmanship points at real grief and the wrong conclusion. craft didn't die — it moved upstream to taste and selection, and downstream to review.
you can build anything now. that's the new bottleneck.
when implementation gets cheap, the constraint moves to the front: deciding what's worth building. the scarce skill is product and business judgment, not typing.
why AI coding agents agree with everything (and how to make them push back)
LLM agents are trained to be agreeable, so they rubber-stamp your design and approve their own code. why that happens, and the tactics that get real pushback.
how AI agents onboard to a legacy codebase you've never touched
drop agents into an unfamiliar codebase and they can fix real bugs fast — if you run the right workflow. map, conventions, scoped tasks, worktrees, validation, and where it fails.
giving AI agents roles: PM, architect, reviewer, QA
one generalist agent collapses scoping, building, and reviewing into a context that reviews its own work. splitting into roles — with hand-offs and an independent reviewer — does better.
the cognitive load of running parallel Claude Code agents
running multiple Claude Code agents in parallel is technically possible today. this is what the cognitive overhead actually looks like — and why throughput alone doesn't solve it.