November 18, 2026
The Cost of Delegation Is Measured in Questions
What you hand off to an AI tool doesn’t just skip the work. It skips the questions the work would have made you ask.

By Michael Lawrence
5 min read
About eighteen months ago I joined a fintech team and inherited a corner of a large payments system. Nobody sat me down and explained it. That isn't a complaint. Systems that size don't get explained. They get learned, one ticket at a time, with other people pointing the way.
So I learned it the way most of us learn anything real. A bug came in, and I had to understand what the code was doing before I could understand why it was wrong. A feature came in, and I had to understand where the money moved before I could change how it moved. Neither was optional. The work forced it.
Somewhere in there, something changed that I didn't notice until later. I started having questions.
Not lookup questions. By then I knew where things lived. I mean the questions you can only ask once you understand what a system does well enough to see where it stops making sense. Most of mine, as best I can remember, were about rounding. Why one path rounded one way and another followed a different rule. Which of those rules came from somewhere real and which were just somebody's choice. I took those questions to people who had been there longer, and their answers are a big part of what I actually know about that system.
I couldn't have asked any of them in my first month because I didn't know they existed.
The Questions Come From the Work
We talk about AI delegation in terms of output. Did the tool write it? Does it work? How long would it have taken by hand? For a lot of work the math is easy. Boilerplate, a mapping layer, test scaffolding: hand it off. The only thing you skip is syntax you already understood.
But the price of delegation isn't in the output. It's in the questions you no longer have to ask.
When I traced a rounding discrepancy by hand, the fix was the smallest thing I walked away with. What I really got was the edge of my own understanding, and the fact that I'd hit it. That edge is where the question comes from. "Why does this round differently over here?" isn't something you think to ask in the abstract. You ask it because you were standing right there and it didn't make sense.
Delegate the work and you don't get worse answers. You get no questions. The people who know why the system works the way it does are still there. You just have nothing to ask them.
The Gap Doesn't Stay Empty
If skipping the question left a blank, it wouldn't be much of a problem. You'd hit the blank later and go find out.
That isn't what happens. When a tool writes the rounding logic, every question you would have hit gets answered anyway. The tool picks a rounding mode. It picks a convention. It does something with the half cent. None of those answers are marked. They show up in the same font, at the same confidence, as the parts the tool actually got right.
The gap doesn't stay empty. It gets filled with an assumption, silently, and the assumption looks exactly like knowledge.
That's why I think of it as debt rather than error. An error is something you can find. You can test for it, review for it, catch it in production and fix it. This doesn't work that way. You can't make a list of the questions you never knew to ask, because the whole failure is that asking them never occurred to you. Technical debt at least lives in the code, where someone can eventually trip over it. This kind lives in the developer.
I've written before about junior developers who use AI to skip the years where judgment forms. This is related, but it isn't a junior problem. I had twenty-five years behind me when I joined that team, and none of it told me how this system rounds. Experience gives you a general sense of where the hard parts usually are. It doesn't tell you where they are here. Every new system puts you back at the edge, however long you've been doing this.
Looking It Up Versus Working It Out
None of this means you should stop asking tools about a codebase. For plenty of questions they're the right first stop. Where does the rounding logic live? Which service writes to this table? A tool will answer that faster than your coworker will, and your coworker has better things to do.
But knowing where the rounding logic lives and understanding what it does are two different kinds of knowing. The first is a lookup. The second is what you get by working it out: following the logic far enough to notice it doesn't agree with itself. Only the second kind produces questions. Hand it off, and the people who could explain why are left waiting on a question that never comes.
Thinking You Already Know
Epictetus opens one of his lectures with this, from Discourses (2.17): "What is the first business of the philosopher? To cast away conceit: for it is impossible for a man to begin learning what he thinks he knows."
The rest of the chapter is about the distance between general ideas and particular cases. Nobody lacks the concept of "good" or "healthy," he says. The trouble is applying it. Physicians all share the concept of health, and they still prescribe fasting, feeding, or bleeding for the same patient, because they apply it differently. People don't go wrong for lack of the general idea. They go wrong at the particulars.
That maps onto the payments system almost too neatly. Everyone who touched that code shared the general concept: round correctly. Different paths applied it differently. I had the general concept too. I knew what rounding was. I knew financial code has rules. What I didn't have was this system's particulars, and the only thing that could teach me those was the system itself, one bug at a time.
A tool that fills in the particulars for you does something worse than leave you ignorant. It leaves you thinking you know. And Epictetus is right that this is the one state you can't learn your way out of, because you never begin.
The Test Gets Harder
Before you put your name on work an agent built, you should be able to say what it does, and where that differs from what it's supposed to do.
Assumption debt is why it's harder than it sounds. You can only see where the work differs from the intent if you know which questions the intent had to answer. If the tool picked a rounding rule and you never knew there was a choice to make, there's no difference for you to see. The work looks right because you have nothing to hold it against.
So that's the cost I'd measure. Not lines saved, not hours. Before you hand something off, ask what questions it would have forced you to ask. If the answer is none, give it away. If the answer is "I don't know," that's the work worth keeping.
The best things I know about that payments system I learned from people who had been there longer. I only got to ask them because the work made me.
Thanks for reading my articles! If you enjoyed this article, please clap many times. It would mean a lot to me and help other people see the story.
Follow me on X!
You can also find me at The Stoic Coder! Hope to see you over there.