Blog

Notes on AI, properly done.

Weekly essays on methodology, agents, products, and what breaks when AI meets real software. Written as the work is done.

On this page

Related reading

  • Start here

    AI software, properly.

    Some context. Where this site is coming from, and why I've stopped pretending the way most companies build software is normal.

  • Company of one, built like fifty.

    The pitch most of us have had put to us is to look like a fifty-person shop. The shape earns its lines from fifty people sharing the standard, not from the standard itself. Three practices from the bigger firm to copy, two to leave behind, with a one-person shape for each.

  • The proof passes. Of what?

    Boris Cherny formally verified the Claude Agent SDK with Opus 5.5 and Lean and got sixteen bug-fixing pull requests out of a couple of prompts. Good news for anyone who cares about correctness. It also leaves a sentence half finished. A proof passes against a property. Who said the property was the right one, and where is that written down?

  • Hand the agent one build spec and count the questions.

    We put one of our own delivered build specs in front of a coding agent cold, told it to ask rather than build, and counted. Twenty-nine to thirty-nine questions a run, about fifteen of them real gaps. The count is a better readiness test than any review score, and it costs one session.

  • One agent, three powers, no gate.

    I approved an overnight agent design in principle that put three powers in one session without a human gate. An adversarial review caught the problem before we built any of it. Meta's Agents Rule of Two helped us redraw the boundary.

  • Governance moved inside the build.

    Security leaders and private equity operating partners in my feed are agreeing on AI governance. It needs to be built into the software and checked by machines on every change. Security did this when work moved beyond the perimeter. After a year running governance this way in production, I don't think an oversight office can keep up with coding agents.

  • Vibe coding at enterprise scale: the review that never happens.

    Vibe coding keeps climbing the search charts, and every enterprise governance post carries the same line about a senior engineer reviewing all AI-generated code before merge. Nobody has the hours, so the line stays in the policy and the review gets skipped. Last week I forced that review onto my own code twice, using two coding agents that argue about a codebase in front of a referee. Twelve real defects in four small files, and six of them were in the fixes for the first six.

  • Harness without a spec is a loop without a target.

    Harness engineering has the loop close to solved. Plan, act, verify, repeat, with humans steering rather than typing. But almost every harness points the verify step at proxies, tests the agent wrote, lint, a second model's opinion of the diff, and a loop aimed at a proxy converges on the proxy. A guard job in my own CI sat green for five weeks while blind to the one thing it existed to check. The missing half of the discipline is the target, a spec layer the loop can verify against.

  • The local model won one of my five tools.

    A 122GiB open-weight checkpoint on a desktop box beat Claude Opus 4.7 outright on one of the five production CLI tools in my benchmark, at electricity prices, two days after release. It also lost to everything on another one. The pair of results matters more than either half, because together they say the unit of model choice is now the tool, not the estate.

  • Your tests passed. Your suite lied.

    An unattended AI build shipped an email channel with an integration suite at twelve of twelve green, marked approved, and no API key had ever existed in the build. A human caught it by hand, days later, and a sharper reviewer would not have done better, because the lie lived in what the record could not say. The fix is evidence the record can check, not reviewers who happen to notice.

  • The frontier gap, measured.

    Qwen's model card puts a 27B you can run on a desk head-to-head with Claude Opus. I benchmarked that claim on five real tools. Three verdicts went local, two stayed frontier, and the gap is smaller than I expected.

  • You're reviewing the wrong thing.

    Two posts, a thousand-plus reactions each, spent the week fighting over whether engineers should still read AI-generated code. Both camps are reviewing the code. The review that decides whether the software is right needs to point at the chain that produced it.

  • Finish zero trust before you buy AI security.

    Agentic AI needs three layers of defence. Two are controls you have already bought. The third is design work, and the products being sold in its place do not survive a live attacker.

  • Harness Engineering Has a Hole Where the Requirements Should Be

    The 2026 harness wave has nailed the loop mechanics. OpenAI shipped a million agent-written lines, Anthropic taught agents to survive losing their own memory, and Thoughtworks mapped the discipline properly. Every one of those loops closes on tests and lint. None of them can tell you whether the software does what anyone asked for.

  • Merged is not live.

    Staging a build and releasing it on purpose is ancient, boring practice, and almost nobody runs it at the size of one person. Agents writing most of my code changed that maths. The release model I put on three live apps in a weekend, and why I left myself no way round it.

  • The knowledge library behind a digital operator

    My digital operator runs across a dozen surfaces and has to remember what it learns. Not in a chat log, not in a vector blob. Here is the library I built for it, and where I stole the shape from.

  • Someone built RCF from the docs

    Sebastian Beaton scraped nineteen methodology pages off this site and turned them into working tooling for his business, without me over his shoulder. Here is what held, what he bent on purpose, and the gap he found that I left open on purpose.

  • One graph or two: how we chose CodeNodes for RCF's spec-to-code bridge

    RCF's traceability chain was complete on the spec side and stopped dead at the code. Here is the design call I made to carry it across, and the two-graph approach I turned down to get there.

  • AI code governance starts at the requirement, not the policy.

    The audit firms are building their own AI tools this year, and most published policies sit on top of engineering that produces nothing those tools can read.

  • Context engineering. The model isn't wrong. It's weighting the wrong thing.

    The craft moved upstream, to requirements and architecture. Context engineering is the orchestration tier inside that.

  • Vibe coding belongs upstream of the PRD.

    Prototyping is a discovery move. Treat it as a delivery move and the audit trail starts at the moment an agent guessed.

  • The fate of the human engineer.

    The role was never static. AI just made the rate of change impossible to ignore.

  • Ninety-six percent don't trust AI code. Half of them check it.

    The AI trust gap is a methodology problem, and the industry keeps reaching for tooling instead.

  • How much do you trust human output?

    Every AI failure mode has a human equivalent that predates large language models by decades. The common root cause is the one nobody wants to examine.

  • Nobody owns the requirements anymore.

    Requirements used to be somebody's job. Then we hollowed the role out, and now AI is filling the gap with guesswork.

  • The last twenty percent.

    What's actually hiding in the part of the build that AI skips past, and why it still bites.