AI Agents Can Ship Your Code. They Can't Be the DRI.

The term Directly Responsible Individual started at Apple and got formalized, publicly, in GitLab's handbook: a DRI is the person "ultimately accountable for the success or failure of a specific project, initiative, or activity." Critically, the DRI isn't necessarily the person doing the work — they're the one the buck stops with when it's done, or when it isn't.

Developer and researcher Simon Willison picked the term up in a recent post and pointed it at a question a lot of engineering teams are quietly avoiding: as LLM agents take on more of the actual building, who's the DRI on work an agent touched? His answer is blunt — never the agent.

Why accountability doesn't transfer to a model

Willison's argument isn't about capability. Agents can write, test, and ship real code today — that's not in dispute. The distinction is that a DRI has to be able to *answer* for a decision: explain the tradeoff, take the consequence, adjust the next call based on what happened. A model doesn't hold that in any meaningful sense between sessions. It can't be held accountable, so it can't be the one accountable.

A computer can never be held accountable, therefore a computer must never make a management decision.

— IBM training document, 1979 (cited by Simon Willison)

The line is decades older than the current wave of agentic tooling, which is the point — this isn't a novel AI-safety concern, it's an old organizational-design principle that agentic coding just made urgent again.

The practical version, for teams actually running agents

Translate DRI into an agentic-dev-tooling context and the shape is familiar to anyone running Claude Code, Cursor, or a custom agent loop against a real codebase:

• An agent can be the executor on a task — write the diff, run the tests, open the PR.
• A human has to be the DRI on the merge — the one who reviewed it, understood the tradeoff, and owns what happens if it breaks prod.
• Delegating *execution* to an agent is a productivity gain. Delegating *accountability* to an agent is just accountability going missing.

This is also why fail-closed review gates matter more, not less, as agent throughput goes up. An agent that can generate ten PRs an hour doesn't reduce the number of humans who need to actually own outcomes — if anything it raises the bar on having someone who reads the diff before it ships, rather than rubber-stamping volume.

The org-design gap agentic tooling is exposing

A lot of "AI agent governance" writing focuses on model behavior — guardrails, sandboxing, tool permissions. Willison's framing is a reminder that some of the gap is just plain org design: does every piece of agent-touched work have a named human who's actually accountable for it, or has "the agent did it" quietly become an accountability sink? Teams that never had clear DRIs for human-written code won't get clarity for free just because an agent is now in the loop.

Where TRAGenX sits on this

This is squarely in the territory we teach in the Vibecoding Academy: agentic tools are execution leverage, not a substitute for a human who owns the call. The teams getting the most out of Claude Code and similar tools aren't the ones removing themselves from the loop — they're the ones getting faster at the parts that still require a DRI.