The Responsibility Funnel: AI Can Do Nine Tenths — Why the Last Tenth Is You

Preface

After GitCrisp and the blog as a production line, the most natural next question from a reader is: if AI can do this much, what’s left for you?

My answer is a shape: a funnel. Most of the volume of the work really can go to AI — code, tests, docs, first drafts, research; the ring at the top keeps getting wider. But some things don’t fall through. They get pushed down into a neck that keeps getting narrower — and the one standing in the neck is always a person. This post is about that shape: why it’s a funnel, what’s inside the neck, and what the person in it (including the junior who isn’t there yet) should do.

Conservation of responsibility: to a person it splits, to AI it reflects

First, the physical law underneath the funnel. There are two completely different ways to hand work off:

Hand something to a person and part of the responsibility transfers with it. That isn’t buck-passing, it’s the basis of how organisations work: when something breaks, “that piece was theirs” holds, and it should hold — otherwise delegation is a word with nothing behind it.

Hand something to AI and the work leaves, but not one gram of the responsibility does. No incident review has ever accepted “the AI wrote it” as a conclusion. I wrote about a real overselling incident in the live-commerce series — afterwards nobody asked who wrote that code, only who let it ship. There was no AI writing code back then, and the question needs no editing today. Output can be multiplied tenfold; responsibility doesn’t become a tenth. It’s conserved, and all of it converges on the person who signed.

This is the one place where “working with AI is like leading a team” (the conclusion of the GitCrisp post) stops being true: the methods are the same — write the spec, draw the boundary, review — but leading people ends with handing the responsibility over too, and leading AI always ends with you keeping all of it.

The funnel: volume falls, responsibility density rises

Put conservation of responsibility into a daily workflow and you get the shape of a funnel:

There’s an engineering corollary in that picture worth stating on its own: the throughput ceiling of the whole line isn’t AI’s rate of output, it’s the width of the neck. AI can produce twenty PRs a day; if you can responsibly accept three, the line runs at three — the rest either queue, or flow out without having actually been checked (more on how dangerous that is below). No amount of parallelism compresses the conserved part. That’s Amdahl’s law, except this time the non-parallelisable part is called responsibility.

So “what is your value now that you use AI” has a concrete answer: your value equals your neck width — you’re worth as much as you can responsibly accept.

The neck can be widened, but not removed

GitCrisp’s thirteen thousand lines of tests, the architectural rules in its CLAUDE.md, the blog line’s avoid-word scan and pre-commit hook — the nature of those guardrails can now be stated precisely: they are all tools for widening the neck. Turn a check that used to need human eyes every time into something a machine runs, and human acceptance bandwidth is freed for what machines can’t check: direction, trade-offs, taste.

But two honest boundaries.

First, the recursion still bottoms out at a person. The tests were written by AI too — so who accepts the tests? The spec was organised with AI’s help — who accepts the spec? The recursion has no end, only a stop-loss: humans spot-check the guardrails themselves. I review a test PR harder than a feature PR, because a broken guardrail fails silently — it doesn’t raise an error, it just stops catching things from then on.

Second, a rubber stamp is a fake neck. Aviation learned this decades ago: the better the automation, the easier it is for the human to become incapable — autopilot so reliable that the pilot’s hand-flying and vigilance decay together, and when a human really is needed, they can’t take it. The code-review version: nine times out of ten the AI’s code is right, and by the tenth you’ve stopped looking. The neck is still drawn on the diagram, but it no longer exists — everything goes straight out the door while the responsibility stays with you. A neck isn’t created by drawing it; it’s maintained by actually looking, and actually blocking things. That’s why I read every one of GitCrisp’s hundred-plus PRs: not only for that PR, but to keep “I’m looking” true.

Reflection: what about juniors

The cruellest corollary of this model lands on juniors. The old growth path started at the wide end of the funnel: write a lot of code, write it badly, get taught by production, and a few years later judgment has grown and you move towards the neck. Now the wide end belongs to AI — and the raw material of acceptance ability is the experience of producing, which AI took. The bottom rungs of the ladder are gone.

My current answer is three things, written for people who can’t stand in the neck yet:

One: the raw material of judgment is a library of failures, not a typing count. You can smell bad code because you’ve seen enough bad code — your own, dug out of incidents, caught in review. Typing was the old era’s carrier for accumulating that library, not the thing itself. So the new practice is to swap “write → break → learn” for a much higher-frequency “predict → verify” loop: before you look at the AI’s diff, guess how it will write it and where it will go wrong, then open it and check your answer. Every wrong guess goes into the library. AI makes this practice unbelievably cheap — you can have it explain every decision, generate three alternative implementations to compare. It took the old training ground and opened a new one; the difference is that the old one trained you passively (no code written, no project), and you have to walk into the new one on purpose — accept everything without asking and you train nothing.

Two: neck width = speed of acceptance × calibration. Fast alone is worthless: accepting quickly while overconfident is a fake neck — everything flowed through, but nothing was really checked. Real neck width includes knowing where you don’t understand, and for those parts slowing down, adding a guardrail, or honestly saying “I can’t sign this one yet”. Misplaced confidence is far more dangerous than being slow — and calibration, as it happens, also grows out of the library of failures.

Three: be the neck of a small funnel before you’re the neck of a big one. “The scope you can be responsible for” isn’t only a cognitive question, it’s a trust question — the scope you can own is the scope other people dare to let you own, and that gets built from a record of signatures. Rather than owning one wide layer inside a big system (a layer AI keeps taking over anyway), find a small complete funnel and walk the whole thing — spec, acceptance, and carrying the blame when it breaks: a side project, a small tool, a small service. That’s also how I look back at the travel-split tool and GitCrisp now: they aren’t just pieces of work, they’re where I practise being the neck. In the age of AI a side project stopped being a bonus and became the real thing — because it’s the one funnel where you stand in the neck from day one.

To end on one sentence: what AI changed is how wide the top of the funnel is, not how narrow the bottom is. Output inflates, responsibility doesn’t — and your career is that neck, slowly getting wider.