Last year, the fastest path through an AI coding session was a sharper prompt. That's still true for one-off tasks. But for engineers who have run daily agentic coding sessions for months, the calculus has changed. The model isn't the bottleneck. The human workflow wrapped around it is.
This is the core finding from practitioners who have been running Claudee Code](/tools/claude-code/) continuously since near its launch - spending a year assuming the path to speed was a better model or a tighter prompt, then realizing neither was the actual constraint.
The xkcd Math No Longer Holds
There's a useful reference point here: xkcd strip #1205, "Is It Worth the Time?" It's a chart showing how long you can spend automating a task before the automation effort costs more than it saves. The chart assumes the expensive part of automation is you, sitting down to write the script or configure the pipeline - time measured in hours.
Agentic coding collapses that cost. Claude Code can scaffold a working implementation in minutes. The engineering cost of automation has dropped by roughly an order of magnitude for a wide class of tasks. Tasks that weren't worth automating two years ago now are. The xkcd threshold has shifted substantially.
But the cost that hasn't dropped is defining the problem clearly enough for the agent to build the right thing. Scoping the task. Writing a precise spec. Reviewing output. Catching when the agent drifts from intent. Deciding when to stop and redirect rather than let a session run off-course. That decision loop is still expensive, and it's still human.
What Changes When the Model Isn't the Problem
The practical implication is that vague instructions are more costly now, not less. Previously, a fuzzy spec wasted an engineer's time while they built something wrong. Now a fuzzy spec wastes two or three AI cycles and a review session before you converge on something useful. The shape of the problem changed - the total cost is similar, but where it sits has moved.
Practitioners who are getting consistent results from Claude Code tend to front-load clarity: writing tight specs before starting a session, maintaining a CLAUDE.md file that encodes project conventions the model should always know, and treating agent output as a competent first draft rather than a finished product. The agent handles implementation. The human still has to own the problem definition.
There's also a shift in how to think about task selection. When spinning up an implementation takes ten minutes instead of ten hours, the automation ROI threshold drops far enough that tasks you'd never have bothered automating now make sense. The right mental filter isn't "is this worth a day of work?" - it's "can I write a clear enough spec in fifteen minutes to get something useful back?"
After a year of daily use, the speed gains from agentic coding are real. But they don't come from the model getting faster or the prompts getting smarter. They come from the user getting better at the part that only a human can do: deciding what to build and recognizing when the output is actually correct.