34 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 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 readAI support drafts are fluent and frequently wrong — invented policy, steps that don't exist. ADD makes the source-of-truth the contract, factuality-against-source the red test, and a measured hallucination rate the evidence — so confident wrong answers are caught before they reach a customer.
10 min readWhen agents and teams produce more than any leader can read, line-by-line review collapses. ADD reframes the job: the ADR and its fitness functions are the frozen contract, fitness checks are the red tests, and production evidence — not a clean diagram — is how direction is verified.
13 min readAn AI-built model reconciles at a glance and hides a broken assumption or a double-count. ADD locks the assumption set as the frozen contract, makes reconciliation and integrity checks the red tests, and verifies by backtest against actuals — not by whether the numbers look reasonable.
15 min readAI screening reads objective and can be quietly biased. ADD makes the calibrated rubric the frozen contract, a gold-set plus counterfactual bias probes the red tests, and adverse-impact tracking the evidence — so a human, never the model alone, owns every decision about a person.
11 min readML is AI building AI, and a high headline metric hides leakage, gamed proxies, and slice regressions. ADD locks the eval set, thresholds, and model card as the frozen contract, makes the held-out suite the red tests, and verifies by slices and online evidence — not by the leaderboard number.
14 min readLegal is where ADD maps most literally — the negotiation playbook is the frozen contract. AI drafts and redlines read authoritative and can quietly concede a material term; ADD makes playbook-conformance the red test and an adversarial redline the evidence, with off-playbook concessions a hard stop.
12 min readAI floods marketing with on-brand-looking copy that is off-strategy. ADD fixes it: the brief is the spec (with named refusal reasons), brand and claims are the frozen contract, the A/B test is verification by evidence, and performance folds into a living playbook.
11 min readAI can generate plans and status that look complete while the goal is unmet. ADD makes evidence-backed exit criteria the contract, the dynamic goal-loop the engine, and an artifact — not a self-reported 'green' — the proof a milestone is actually done.
12 min readAI can flood prospects with personalized-looking outreach that is off-ICP, mis-priced, or non-compliant. ADD clamps the what — ICP, claims, pricing authority — and frees the how, then verifies by reply and win rates instead of by how persuasive the copy reads.
13 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 readAd-hoc prompting is fine for one-off questions. Repeatable workflows deserve structure. This post dissects how a production harness defines, discovers, loads, and executes skills — reusable AI workflows that turn tribal knowledge into executable automation.
8 min readEvery AI assistant starts each conversation knowing nothing about your project. Context files change that — they encode your stack, conventions, and constraints so the AI works with your codebase instead of against it. This post shows how to build the foundation layer that makes every skill smarter.
9 min readYou have been typing instructions into AI assistants one conversation at a time. Skills flip that model — they turn your best prompts into reusable, structured workflows that any team member can run. This post explains the shift from ad-hoc prompting to skill-driven development.
7 min readA skill is not a long prompt. It is a structured workflow with a trigger, a prompt body, references, and an output contract. This post breaks down each component, shows how they interact, and explains the design decisions that separate skills that work from skills that frustrate.
11 min readFour complete skill definitions for workflows developers actually do every day — debugging, code review, technical writing, and deployment. Each pattern is tool-agnostic, tested in production, and ready to adapt to your own projects.
13 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 readYou have used AI skills. Now you build one. This post walks through the complete process: identifying a repetitive workflow, extracting it into a structured skill, testing it against real work, and iterating until it reliably produces quality results.
9 min read