25 posts
Same AI, same codebase, same money-critical feature — built two ways. An apples-to-apples walk through 'normal' AI coding versus pro AI-Driven Development on a real billing-reconciliation milestone, with the tests, gates, and numbers that separate hope from proof.
11 min readIn a large codebase the bottleneck isn't how smart Opus is — it's how precisely you point it and how tightly you verify. Six portable moves to steer a fast agent so its speed lands on the right target instead of becoming faster waste.
19 min readYou left the enterprise SDLC — change boards, QA gates, sign-offs — to vibe-code solo with an AI. The safeguards didn't have to follow you, but their jobs did. A field guide mapping each one to its lean ADD equivalent, grounded in two real solo projects.
16 min readA controlled comparison: two AI workflows build the same forty-line function from one spec. GSD records it in five files and 644 lines of prose; ADD in a 22-line contract. Real recovered artifacts and exact token logs show ADD spent 5× fewer tokens with the same passing tests.
14 min readNous Research's Hermes Agent ships a learning loop inside its runtime — act, then a background thread folds lessons into memory and skills. It's the back half of ADD's loop, in code. What that proves, what it's missing, and why the two compose.
10 min readHermes Agent proved an AI agent can run a self-improving loop — but it's bolted to the Hermes runtime. ADD gives you the same compounding loop on Claude Code and Codex, plus the safety gate Hermes lacks. The loop becomes an asset you own, not a feature you rent.
9 min readAI-Driven Development isn't a replacement lifecycle — it re-wires the one you already run. A stage-by-stage field guide mapping ADD onto requirements, design, dev, review, test, security, release, ops, and maintenance — grounded in two real projects.
19 min readA data-driven companion to the ai-proxy field study. Mining the transcripts and the .add foundation to measure an AI-driven build across the full SDLC and every role, against modeled human baselines of 6 person-months to 32 person-years, with the caveats that keep the comparison honest.
27 min readADD and Claude Code's Plan Mode both fix direction before an agent builds — but at different scales. Plan Mode is an in-session, read-only guardrail; ADD is a cross-session, evidence-gated method. Why the question isn't which, but which layer.
14 min readThe five competencies behind AI-Driven Development — Domain, Spec, UI/UX, Test, and AI/Build — and why each is a separate discipline the agent stands on. The foundation that makes 'constrain the what, free the how' actually work.
12 min readAI-Driven Development was born in software, but the method is domain-independent. The producer is now an AI in every knowledge-work domain — so the same loop applies: constrain the what, free the how, verify by evidence. The framework for the whole series.
11 min readA field study of ai-proxy, a multi-tenant AI gateway built end-to-end with ADD: 23 milestones, ~120 tasks, six days, zero waivers. What the method felt like in production and how the LLM behaved when scope was clamped.
12 min readThe frozen contract is ADD's one human gate — the interface, data shapes, and error codes, locked and checksummed before the agent builds. Why it is the single approval that earns the agent its autonomy.
12 min readThe step that closes the loop: Observe production behavior and fold the spec delta back into the next Specify. How ADD keeps documents living while old-school artifacts rot — and how the method improves itself.
11 min readWhere ADD sits among its neighbors: the lineage it inherits from TDD, DDD, BDD, and contract-first design, and how it differs from spec-kit and GSD by continuing past Verify to Observe and folding the loop closed.
13 min readADD's first two steps kill fast waste before a line of code exists: Specify (Must do, must Reject with error codes, the After-state) and Scenarios (concrete happy, edge, and failure examples in domain language). Pin the what.
11 min readTests-first, pointed at an AI agent: write a red suite that asserts observable behavior, then turn the agent loose with one instruction — make every test pass, change nothing in the tests or the contract. Red to green.
11 min readVerify by evidence, not by reading the diff. ADD's earned-green: an adversarial refute-read that tries to break the result, because AI code is frequently plausible and wrong. Trust through proof.
13 min readAI made writing code nearly free and quietly broke the SDLC. AI-Driven Development — five competencies, eight steps — constrains what an agent builds while freeing how it builds, proven across a 23-milestone production gateway shipped in six days.
26 min readBonus post. Skills are not a new rung on the ladder — they're a way of packaging the rungs you already have, so an agent can pull a mini-playbook off the shelf on demand instead of carrying every instruction in its head. Here's the concept, the mechanism, and when to reach for one.
11 min readOne agent is a worker. A team of agents with a supervisor, evals, tracing, guardrails, and cost control is a platform. Here's when multi-agent actually helps, when it hurts, and the four pieces of scaffolding that turn a demo into a product you can run.
12 min readContext windows forget. Production agents don't. The difference is a layered architecture: working memory, session memory, and long-term memory split into facts, events, and skills. Here's how real agents remember — and why forgetting on purpose matters.
10 min readOne tool call is an API. A loop of tool calls with reasoning in between is an agent. This post walks through the four-step cycle that turns one-shot chat into step-by-step work — and the surprisingly tricky question of when to stop.
10 min readText in, text out — until you let the model call functions. This is the moment a chatbot stops explaining how to do things and starts actually doing them. Here's what function calling really is, the typed contract that makes it work, and why this is the hinge rung of the whole ladder.
11 min readA single skill handles a single workflow. But real development involves chains of workflows — review then fix then test then commit. This post covers composition patterns: how skills delegate to other skills, how hooks automate triggers, and how pipelines chain skills into end-to-end workflows.
9 min read