Every change worth building starts with an intent

One week of SDD: from a first version to a tool that checks its own work.

By day I'm a software engineer and senior architect. In the evenings and at weekends I paint as Sam Grudge: hearts, in oil on canvas, built up layer by layer until the colour glows (hearts-colors.com). The two lives look far apart. More and more, they meet in one question: what do I want to do with my own hands, and what can I hand to a machine?

SDD comes from my day job. It's a spec-driven development skill for AI coding agents (Claude Code and Codex), and it's open source on GitHub. The idea is simple. Before the agent writes code, it writes a short spec: requirements, and concrete examples of how they should behave, including when things go wrong. I approve it. Then the agent builds it test-first, verifies it against the spec, and keeps a living record of how the system behaves.

What changed in a week

The first version came out on 7 October. It handled small changes from end to end, with one approval, test-first tasks and a living spec. Seven days and fourteen versions later:

• Bigger work has its own path. A larger change gets three approvals instead of one: the spec, the plan and the results.
• An approved spec is locked. Changing it afterwards takes a logged, approved amendment. Bugs get their own flow, and a regression test lands in the living spec so the bug can't come back quietly.
• A critic reviews the spec before anything is built. It audits every requirement and asks me only the questions that are mine to decide, five at most.
• SDD now develops SDD. Since version 0.5 the project runs on its own method, at "production" rigour: the second-highest of its four levels.
• The test suite went from 82 tests to 208.

The tool found holes in itself

The first change SDD ran on itself was a bug it had uncovered in its own approvals. The final "results" approval didn't read the reviewer's verdict, so work marked as having gaps could still be approved. The project's constitution, its non-negotiable rules, could be edited after approval without anyone noticing, including lowering the level of rigour.

Both are fixed. An approval now covers exactly what was approved. The results gate accepts only a passing verdict, and the constitution carries a fingerprint: any later edit is reported and blocks progress until I approve it again.

What I liked most was how it got there. Verification ran three times, each in a fresh session with no memory of the work. The first two rounds came back with gaps: rules the spec stated but no test proved. Each time, the spec was amended, the missing tests were written, and the reviewer looked again. The third round passed. Nothing was waved through.

Layers

A painting of mine is layers. The early ones disappear under colour, but they hold everything up. SDD works the same way: intent, then spec, plan, tests and verification, each one visible and checkable underneath the code.

On my website I say every story worth telling starts with a heart. In software, every change worth building starts with an intent. That part stays with me. So do the decisions and the approvals, which carry my own words.

Delegating the grind

Not every layer needs a master's hand. A verification round took about 14 minutes and close to 180,000 tokens, and much of that was mechanical: replaying tests against old code, breaking rules on purpose to prove a test catches them, collecting evidence. A script can do that work, with no model at all.

That's the next step. A prime model will orchestrate: it talks with me, holds the gates and routes the work. Independent reviewers will run as separate agents on the strongest models. Routine tasks will go to cheaper, faster ones. Each kind of work goes to the tool that suits it, the way a brush suits one stroke and a palette knife another.

That's the promise of AI I care about. It doesn't take the craft away. It takes away the grind around the craft, so I keep the part I love. At the office that's architecture and judgement. In the studio, it's the next heart.

SDD is open source under the MIT license: github.com/fpapleux/sdd-skill. The release notes list every version.