I don't trust any AI agent
I don’t trust any AI agent. And yet one just built an entire feature set, almost without my hands on the keyboard. At the end of my last blog post I promised to show you how an OK Point between a human and an AI agent works here. Here it is. It doesn’t run on trust, but on proof.
A quick bit of context: our foundation for the flow is Time-Oriented Software Development. Work flows from a prioritized list, through a concept, across an OK Point, into a strictly time-fixed realization. Extending this OK Point to humans and AI agents is our own evolution, and not everyone is on board. We are. The rest of this text shows why.
STDD: Spec, Test, Driven Development
We’ve given our way of working a name: Spec Test Driven Development, or STDD for short. The starting point is Spec-Driven Development, the idea of making the spec, not the code, the source of truth. Our evolution sits in a single letter: the T for Test. A spec alone describes what should hold. Only the test proves that it actually does, turning a declaration of intent into a verifiable agreement.
Three parts, three jobs:
- Spec is the agreement: what gets built and which conditions apply. It is the OK Point in written form, not a shout across the room.
- Test is the proof: whether the agreement held is decided not by gut feeling, but by an objective, green result.
- Driven Development is the flow: from a prioritized list, across the OK Point, into a time-fixed realization.
Every round runs the same way:
- Every piece of work begins as a Task on a prioritized list.
- The AI agent proposes a Spec. I sharpen it.
- First OK Point: Go, Adjust, or Stop on the spec.
- After Go, realization follows Test-Driven Development: first the tests from the spec, still failing (red). Then the AI agent implements until the tests turn green.
- Then the independent check: a different, specialized AI agent with a fresh context verifies whether the spec actually landed in the code, not the one that built it.
- Second OK Point: the merge. Only once the check confirms the agreement is in the code does it land on Main via a pull request (PR). The path from there to production is a separate, fully automated flow of its own.
Two OK Points, not one: one on the spec, one on the merge. In between, it isn’t the AI agent checking its own work, but a different, specialized one.
The OK Point also sits not at every line, but at the right boundaries. A Task represents a feature, a chore, or an entire Feature Set with its children. That’s exactly why I hand an AI agent not a single change, but a whole Feature Set, and decide only at the boundaries where it counts.
Prompting steers. STDD constrains. The loop proves.
The proof
This is no theory. A Feature Set that implements the inheritance of skills and workflows along our organizational tree, a multi-tenant piece of software rooted deep in permissions, came about with virtually no manual intervention. The AI agent broke it into parts, specified it, built it, tested it, worked in the reviews, and shipped it. I was there at the OK Points. It did the rest. This is the leap from “AI writes code” to autonomous development with responsibility.
And I can prove every step. Every decision, every acceptance, every verification leaves a trail:
A real proof chain from beacon: twelve events, each signed and chained.
No “I think that’s how it went.” Every event is signed and chained to the one before it, a chain no one can alter unnoticed. The audit trail is the OK Point, frozen in time. From the first task to the release in production, everything is on the record. We build beacon with beacon, and the platform’s toughest customer is us.
Why I still don’t trust any AI agent
Because I don’t have to. Trust is what you need when you have no proof. I have the spec as the contract, the tests as the criterion, an independent check before the merge, and the audit trail as evidence. No AI agent merges its code without my permission. Go, Adjust, Stop stays with the human, at both OK Points.
That’s the holistic approach behind the beacon platform: not a tool that spits out code, but method and platform as one system. The method sets the flow. The platform keeps the AI agents on track and makes every step traceable and cost-attributable.
An OK Point between two humans is a handshake: verbal, open to interpretation, remembered differently tomorrow. The OK Point between me and an AI agent is the opposite. It’s the best-documented handshake I’ve ever given.