Skip to content

AI-Augmented Development

Who Is This Document For?

There is a mental model of AI-assisted correspondence that I held until quite recently, and I suspect most people still hold it. It goes like this: two humans exchange messages about shared work. Each of them might have an AI helping — polishing prose, summarizing a long thread, drafting a first version. But the correspondence itself is still human-to-human. The AI is a writing aid, the way a spell-checker is a writing aid. The loop is: I think, my assistant helps me say it, you read it, your assistant helps you answer.

That model quietly died on me over the last few weeks, and I want to describe what replaced it, because the replacement is different in kind, not degree.

The Software Itself Is Becoming Agentic

This week we shipped a feature in Sunstone Atlas where one playbook can, at runtime, call in another playbook as a real sub-orchestration — a crew calling in another crew, each with its own ledger and its own replay story. A playbook can also propose handing off to a successor when it completes; nothing auto-fires, an explicit human act is required to actually start the successor. And neither the calling unit nor the called unit may participate at all until each has separately, explicitly earned certification for exactly that — a binary, human-signed trust decision that can be revoked as easily as it was granted.

Notice what that is. It is not a developer using an AI to write code faster. It is the shipped software making a composition decision at runtime, and being held to a governance standard for making it.

From Pasted Prompts to Signed Charters: A Short History of the Agentic Skill

From Pasted Prompts to Signed Charters — the evolution from a pasted release prompt to a signed, enforceable skill charter

In 2023, if you wanted an AI to help you cut a release, you typed a small prayer into a chat window and pasted the answer into your terminal.

This morning, an agent in my toolchain was offered a release skill by a deterministic planner, which noted — in writing, in a receipt — that the skill was relevant to the task but not eligible to run, because no human had granted it enactment rights. The skill itself declared, in a signed manifest, exactly which tools it may invoke and which files it may touch. A linter had checked that declaration. A different program stood ready to block any tool call that reached outside it.

Same workflow. Same twenty lines of playbook. Completely different kind of object.

The distance between those two moments is about three and a half years, and almost nobody noticed the transitions while they happened — each one looked like a small quality-of-life improvement at the time. Told end to end, they form one story: the agentic skill slowly acquiring the properties of a charter — a scoped, reviewable, revocable grant of authority. This post walks that history with one deliberately boring running example, because boring examples keep us honest: how does the AI help you cut a release?

Three Hooks That Give Claude Code Memory

Every Claude Code session starts from zero. You know your codebase, your conventions, your past decisions. Claude doesn't — until you explain them. Again. Every time.

This is not a Claude problem. It's an architecture problem. The context window is the right unit of work, but it has no built-in mechanism for accumulating knowledge across sessions.

I've been running three passive hooks to fix this for months. Today I packaged them up: kcp-hooks.

Discoverable Is Not Navigable

This morning I spent three hours on regulatory knowledge infrastructure. 63 fragment manifests across Arbeidsmiljøloven, GDPR, NIS2, DORA, AI Act, NSM Grunnprinsipper, Dutch financial supervision law. Fixed a scope validation bug across 30+ files. Extracted 38 Dutch obligation units from inline YAML to standalone navigable text. Everything passing kcp validate by lunch.

None of it would normally get published. Too narrow. Too technical. No audience in the traditional sense — a compliance engineer isn't subscribing to this blog, and a developer evaluating KCP isn't refreshing the RSS feed waiting for fragment extraction patterns.

That instinct is correct. If you're writing for humans, ruthless editing is the right move. Cut the scope validation bug. Keep the summary. Optimize for skimmability, because human reading bandwidth is fixed and attention is scarce.

The instinct is right. The assumption about who's reading has become incomplete.

Explorative Development

Practitioner notes on engineering as a sequence of experiments — and on who does what in the loop.

Before we wrote the production code for a recent platform feature, we ran a fictional organization through two years of using it.

Twenty-four simulated months of compliance life: onboarding, supplier churn, audits, incidents, people leaving with their knowledge. The simulation produced fifteen architectural findings — wrong assumptions and missing pieces, discovered while every fix was still cheap and no customer existed yet. Sibling simulations took the total to twenty-five. A design meeting on the same material would have produced opinions.

That run is the clearest recent example of how I've worked for years, and of what I've started calling the approach out loud: explorative development. An idea becomes a hypothesis. The hypothesis becomes the cheapest implementation or simulation that could prove it wrong. The result gets verified. What survives is kept — and what was learned gets encoded, either way.

It is not a new method. It's the scientific method wearing a hoodie. Two things are new: the price list, and the fact that I no longer run the loop alone.

False Alarms and False Assurances

Practitioner notes on verifying what your agents tell you.

This week an agent told me, confidently, that an API endpoint had no authentication.

It did. The router was mounted twelve lines after the auth middleware. The agent had read the route file — clean, self-contained, no auth code in sight — and reported what it saw. What it saw was true. What it concluded was false.

The same afternoon, two more claims from the same research run didn't survive contact with the source: a parser described as "fully RFC compliant" (it lacked the wildcard support the RFC requires), and a plugin described as "active" (it was active only because of an import side effect in an unrelated legacy file — a load-order accident no test asserted).

Three wrong claims, one afternoon, inside an otherwise excellent piece of agent research that compressed days of code archaeology into hours. This is not a complaint about agents. It is a job description for the human.