You Don't Get Stuck Anymore

Every engineer knows the failure mode that doesn’t show up in a velocity chart: the project that quietly dies in a debugging dead-end. Not the feature that took longer than estimated — the one that hit a wall nobody could climb. A config that won’t load and won’t explain itself. A race condition that vanishes under a debugger. A dependency two layers down that’s subtly wrong. You burn a day, then a weekend, then you stop opening the repo. The project isn’t behind schedule. It’s dead.

The most underrated claim about AI-assisted development is that this category is shrinking. Not “code gets written faster” — that’s the boring, measurable part. The interesting part is that the indefinite stalls, the ones that used to halt projects outright, mostly stop happening. As one builder put it on a recent conversation hosted by Naval: “you just don’t get stuck anymore, which is pretty amazing.” That episode is the seed for this post; the question here is whether the claim survives contact with the evidence.

Why “stuck” was always the real cost #

Start with where the time actually went before agents. A 2021 observational study by Alaboudi and LaToza, which coded 30 hours of professional developers debugging in live-streamed sessions, found that debugging time is wildly skewed: most episodes resolve in a few minutes, but a long tail of episodes runs past 100 minutes, and the bulk of total debugging time lives in those long episodes (arXiv:2105.02162). The distribution matters more than the average. Your week wasn’t lost to a hundred small bugs — it was lost to the two that wouldn’t die.

That’s the structural reason “not getting stuck” is the load-bearing benefit. The cost of software was never the median bug; it was the variance. If agents flatten the tail — if the 120-minute episode that might have become a 12-hour one collapses back into the few-minute bucket — that’s a bigger change than any uniform speedup, because it removes the thing that kills projects rather than the thing that slows them.

What the controlled evidence supports #

The cleanest causal evidence is a 2023 randomized experiment from researchers at Microsoft, GitHub, and MIT: developers given GitHub Copilot completed a JavaScript task 55.8% faster than the control group (1h11m vs 2h41m, p = .0017), and the gains skewed toward less-experienced developers (Peng et al., arXiv:2302.06590). That last detail is the tell. The people who benefit most are exactly the ones most likely to hit a wall and quit — junior developers, or anyone working at the edge of their own knowledge. The model is most valuable precisely where you’re weakest, which is where “stuck” lives.

Survey data points the same direction. The JetBrains State of Developer Ecosystem 2025 reports 85% of developers now regularly use AI tools, and one in five saves eight or more hours a week. The savings cluster on boilerplate, searching for information, code conversion, and documentation — the context-breaking grunt work that used to knock you off a problem mid-thought. And a longitudinal study of 518 open-source repositories found that projects adopting an autonomous agent as their first AI tool saw commits jump and lines-added climb sharply, with peak effects above +100% commits for agent-first adopters (arXiv:2601.13597). Agents, not just autocomplete, are clearing the path-of-least-resistance work that previously stalled momentum.

The effect scales past hobby projects. Goldman Sachs began piloting the autonomous coding agent Devin alongside its roughly 12,000 human developers in mid-2025, with CIO Marco Argenti framing it as a “hybrid workforce” and pointing to large productivity multipliers in early use (CNBC; IBM Think). You can discount enterprise enthusiasm — pilots are not deployments — but a 165-year-old bank does not casually put an autonomous agent next to its entire engineering org as a press stunt.

Where the wall moved, not disappeared #

Here is where builder honesty has to kick in, because the strongest version of “you don’t get stuck anymore” is wrong, and the evidence that contradicts it is as good as the evidence that supports it.

The most damning result comes from METR, which ran a randomized controlled trial with experienced open-source developers working in mature codebases they knew well — an average of five years on the repo. With AI tools allowed, they were 19% slower, even though they predicted a 24% speedup and believed afterward they’d been sped up (METR, 2025; arXiv:2507.09089). Note this is METR’s finding, not a vendor’s — and it’s the inverse of the Copilot result. The synthesis is the interesting part: AI removes stalls at the frontier of your knowledge and adds friction at the depth of your expertise. When you don’t know the answer, a confident draft unblocks you. When you do, prompting, reviewing, and correcting a confident-but-wrong draft costs more than just typing the thing.

The “almost right, not quite” tax is real and widespread. The 2025 Stack Overflow Developer Survey found 66% of developers cite AI answers that are almost right as their top frustration, and 45% say debugging AI-generated code takes longer than writing it from scratch. That last figure should stop you cold, because it describes a brand-new dead-end: you’re no longer stuck on code you wrote and understand — you’re stuck on plausible-looking code you didn’t, which is a worse place to be stuck.

Then there’s the debt you don’t see at ship time. The same 518-repo study that found velocity gains also found that static-analysis warnings rose roughly 18% and cognitive complexity rose roughly 39% in agent-assisted repositories — and that those costs persisted after the velocity advantage faded (arXiv:2601.13597). Quality is a separate axis from quantity: Georgetown’s CSET, reviewing the literature on AI code generation, reported that nearly half of the AI-generated snippets studied contained bugs judged to be impactful (CSET, 2024). So the project you “unblocked” in week one can hit a harder wall in month six — a complexity wall, a security audit, a maintainability collapse. You didn’t remove the dead-end. You moved it downstream and made it more expensive to reach.

And the personal-vs-organizational gap is worth naming. The 2025 DORA report found no relationship between AI adoption and reduced friction or burnout across organizations. “I don’t get stuck anymore” can be a genuine individual experience that simply doesn’t aggregate into a team-level outcome — because what you saved in personal flow, the org spent on reviewing, integrating, and trusting more machine-generated code.

So is the claim true? #

Partly, and with a sharp edge. The honest version: agents don’t make you un-stickable, they relocate where you get stuck. They are most powerful at the boundary of your competence, where the old failure was giving up — and there the effect is dramatic. The barrier between “idea” and “working prototype” has genuinely collapsed at the low end. A solo developer who’d left an idea untouched for five years, blocked on design and scope, shipped a working SaaS with paying users in 30 days; the unlock wasn’t typing speed, it was compressing a six-month risky bet into a one-month survivable one, which changed which problems felt worth attempting at all (Indie Hackers). More dramatically, Peter Steinberger built the first version of OpenClaw — an LLM wired into messaging apps that could browse and run shell commands — in a single evening; within weeks it had drawn six-figure GitHub-star counts and acquisition interest from Meta and OpenAI, and it eventually went to OpenAI on the condition it stay open-source (Steinberger; CNBC). The gap between intent and a running thing is the gap that closed.

But “not getting stuck on the way up” is not the same as “not getting stuck.” The expert at depth gets slower. The inheritor of AI-generated code gets a new, nastier class of dead-end. The complexity and security debt show up later, at higher cost. The right mental model isn’t “the walls are gone.” It’s “the walls moved” — earlier in the process, fewer fatal cliffs at the start; later in the process, more compounding-debt cliffs at scale. Which trade you want depends on what kills your projects. If it’s the cold-start stall, this is the best moment in the history of software to be you. If it’s the day-1,000 maintenance wall, you just signed up to hit it faster.