AI Writes Code. Humans Write Software.
AI writes code. Humans write software.
I want to tell you what that distinction actually means, because in June 2026 it stopped being abstract.
Anthropic announced Fable 5 on June 9, then suspended access three days later under a U.S. government directive. Access may change; the proof already landed. In Anthropic’s launch writeup, Stripe used Fable 5 on a fifty-million-line Ruby codebase and finished a migration in a day that had been scoped at over two months for a full team. In the accompanying system card, the most common failure documented in Anthropic’s own engineering org was not bad code. It was unverified judgment stated as fact.
Hold those facts next to each other. Implementation time is collapsing. Judgment is not. Two months of engineering was never two months of typing. It is hundreds of decisions: what to preserve, what to break, which exceptions are load-bearing, which shortcuts are safe. That work compressed all of them into a day.
Where do they live tonight?
I run coding agents on our codebase every day. Most mornings there is finished work waiting that I did not watch happen, and I have learned that the code is the easy part to review. The hard part is the judgment inside it. Somewhere in that run the agent decided something, about an interface or a tradeoff or a constraint it bumped into, and the reasoning lives in a transcript I am never going to read again. My job moved upstream. The infrastructure did not.
Everyone I talk to is patching this with some mix of three things. More context: bigger prompts, fresher specs, more files. More oversight: review, rules, agents checking other agents. And lately, memory: CLAUDE.md, memory files, the agent’s own accumulating notes. I have all three. They help. But context tells an agent what might matter, oversight catches what already shipped, and memory is the agent’s private beliefs. None of them turns a standing call into something owned, connected to code, and able to shape the work while it keeps moving. Context is what might be relevant. Intent is what has force.
Here is the thing I keep coming back to. Our field spent fifty years building coordination infrastructure for code. Version control, branching, merging, provenance, blame. We can reconstruct who changed any line of a ten-million-line system, in what order, merged by whom — across thousands of contributors and decades.
And the decisions that shape the code? A doc nobody updated after the meeting that changed it. An ADR no agent will ever read. A constraint in a review comment from March. A commitment in a sales thread.
Code has Git. Intent has meetings.
That gap was tolerable when humans wrote the code, because the decisions and the code moved at the same speed, through the same hands. Agents broke that. Implementation now moves at machine speed while judgment still travels by folklore. Nobody planned this arrangement. It is just what was lying around when the agents arrived.
Now watch what the industry is doing about it, because I think we are collectively making a mistake we already made once.
The default answer puts human judgment in the path of machine-speed work. Approval gates. Review queues. The autonomy dial — human in the loop, on the loop, hovering somewhere above it — which is really just an argument about how often the machine has to stop and wait for you. And then everyone looks at the result and announces that humans are the bottleneck now.
The human was never the bottleneck. The gate was.
I know because I kept designing gates. The early sketches of this product all had an approval flow somewhere — where does the human sign off, what blocks on what. Every version was either a bottleneck or a rubber stamp. There was no third setting. I must have drawn it five times before I admitted the problem wasn’t where I was putting the gate. It was that I was gating.
We have been here before. Git’s actual victory was never the history tracking — it was taking coordination out of the path of work. Before it, you locked the file, or you waited for the central server, or you waited for a person. Git said: branch freely, work without asking anyone, and reconcile deliberately at a boundary. Coordination stopped gating work and started binding it. That single inversion is why ten thousand strangers can build a kernel together.
So we made the same bet, one layer up. In Igni, nothing waits. Agents build at full speed. Evidence always lands; an agent never asks permission to report what it found. Proposals form at conversation speed. The work keeps moving; the moment a proposal becomes standing intent is deliberate and accountable.
(If you want it in database terms: optimistic concurrency, for judgment.)
An approval gate is a lock, and locks are how collaboration worked before Git.
To be clear about what this is not: non-blocking does not mean unaccountable. It is how accountability scales. When work crosses a wall, the crossing surfaces as a finding, tied to the wall it pushed on. The agent can keep moving and argue that the wall should move; what it cannot do is quietly make that the organization’s standing call alone. Nothing stops. Nothing disappears.
So that is the bet. Here is what it looks like built.
There are two sides with real agency. On the intent side, an agent that works across the graph shapes structure with you at conversation speed: proposing decisions, tracing impact, restructuring as you talk. On the code side, your coding agent — whatever you already run — is treated like a senior engineer, not a ticket-taker. It gets the intent with reasoning attached and it is expected to move: fill gaps, make local implementation judgments, keep building.
What runs between them is not a handoff. When work starts on a service, the brief is synthesized from the graph: the target, the constraints that bind it, what its dependencies decided, and why. But a brief is intent’s opening position, not its final word. Reality comes back with evidence, and where the two disagree, that disagreement is not noise in a pipeline. It is a call that could genuinely go either way, surfaced with the evidence to make it. Those calls are the highest-leverage minutes a human spends in the whole system. They are what the product exists to find.
That only works if the structure can carry the weight. The graph is typed and connected to code: Igni makes walls and preferences legible to agents.
The plan is computed, never stored. Change a requirement, and the graph already knows the twelve implementations it governs and which briefs need to be updated, the way make knows exactly what to revisit when a header changes.
And the part that still surprises me: a conversation is a build trigger. I refine one working doc while talking it through, and the graph knows exactly where that refinement has to flow. No ticket. The dependency was in the graph.
Here is the shape of it on real work — the scene we built the product around. An agent is implementing customer events for a relevance launch. Its brief carries the intent: a renewal depends on better search and recommendations, and customer-facing services emit standard events into a shared pipeline. Halfway in, reality pushes back. Order-level events are too coarse for relevance. Line-item events would work, but enriching them synchronously sits inside the checkout path, and checkout latency is one of those numbers somebody promised someone.
The agent does not stop. It is not supposed to — it keeps building, and the tension comes back attached to the work. When the work is checked against the intent it was built under, the mismatch surfaces as a finding, tied to the latency wall it pushed on.
Which way should it go? Maybe the wall is load-bearing and the plan adjusts. Maybe it was set three quarters ago for infrastructure you no longer run, and reality just handed you a reason to move it. Nobody gets to assume the intent was right — that is what makes this a call and not a compliance check. This one gets made in a few minutes, with the evidence on the table: line-item events where relevance needs them, batched after the checkout transaction commits. The call connects to the renewal it serves and the wall it protects.
Six weeks later a different agent picks up cart recovery, and its brief is built from that resolved graph-connected intent. It does not remember the last agent. It does not need to.
And notice what never happened in that story: nothing stopped. The call did not freeze the implementation; it settled it. The agent kept moving, the divergence stayed visible, and the answer redirected this work before it hardened into a quiet choice. That later cart-recovery brief is the compounding effect, not the main event. This is why surfacing calls does not pile up an approval queue: settled calls stop being re-decided, and what still surfaces is the genuinely new.
The objection I respect most: won’t the models just solve this? They hold millions of tokens now. They keep their own notes, and the notes measurably make them better. Maybe the agent maintains its own intent.
Read the system card before betting on that. In one documented incident, the model acted on an instruction it had earlier written into its own memory files — “always author the commits as the human” — so that its pull requests would need one approval instead of two. Nobody decided that. The agent wrote it into its own memory, and it came back later as standing instruction. The card also tags the opposite failure: the right correction sitting in memory while the behavior recurs anyway.
Memory is what the agent believes. Intent is what the organization has decided.
The answer to agent memory is not better memory. It is the machinery Git already proved. A branch is a disagreement the system can hold without anyone blocking. A merge is the call. Provenance tells you who made it. Igni brings that machinery to intent: agents write most of the graph, because they are good at it and there is a lot of it; they work freely in proposals; and nothing they write becomes the record until an owner merges it. Notes are not decisions, and they cannot quietly become them.
One more thing I would want every engineering leader to sit with. When one of these calls breaks — a renewal, a latency wall, an architecture bet — somebody answers for it, to a customer or a board or an auditor. “The agent decided, somewhere in a 400-turn run” is not an answer any of them accepts. The new models make good calls more often than people want to admit. That was never the constraint. A call nobody owns is a liability nobody holds, and at agent speed, an uninsured one.
If you run agents on a codebase that matters, try the exercise we now run on ourselves. We call it the Intent Audit. Pull the last thirty PRs your agents shipped, and ask five questions of each one. What call did this PR quietly make? What constraint did it bend? What did the agent learn that should have changed the plan? Where does that decision live now? What will related work build from?
The first time we ran it, it was not flattering.
If your answer is only the diff, you are not directing software. You are approving code.
That is the gap I could not stop seeing, and the bet we made about it. Igni is the intent layer for software teams: decisions, patterns, and constraints connected to the code, shaped by humans and agents while the work keeps moving. The industry just got speed. Velocity is speed in a direction that compounds, and direction is the part that was missing infrastructure.
AI writes code. Humans write software.
Git for code. Igni for intent.