In-depth articles on technology shaping what comes next.

AI Coding Assistants: 5 Myths, Tested

AI coding assistants speed up typing, not software quality. Five myths tested against the real bottlenecks: design, verification, and complexity.

A robot arm floods a factory floor with glowing bricks that pile up at one narrow inspection gate.
Generation got fast. Inspection didn't — and throughput is set by the slowest stage.

Jonathan Blow — the designer behind Braid and The Witness, and a man stubborn enough to spend a decade building his own programming language — recently asked a question that should sting every vendor selling AI coding assistants: if AI has solved coding, why is my software still the same? Same crashes. Same bloated updates. Same decade-old complaints about apps eating RAM while doing less than the tools they replaced. The usual retort — just wait six months — doesn't quite cover it, and I don't think Blow is wrong to poke the bruise.

Here's my position, after years of building ML systems and then watching these tools land on real teams: AI coding assistants are genuinely good now, and they genuinely haven't moved the needle on the software you and I use every day. Both things are true at once, and they're true because the tools were never aimed at the constraint. The clearest way to see it is to take the five beliefs I hear most often and test each one.

Myth 1: Typing Is the Bottleneck in Software Development

The pitch writes itself: coding is the act of producing code, so a machine that produces code ten times faster makes software ten times faster. It's a tidy syllogism with one flaw — nobody's job actually looks like that. There's an old rule of thumb, popularized by Clean Code, that developers spend well over ten times as long reading code as writing it. That ratio predates LLMs by fifteen years, but every serious look at how engineering hours get spent lands in the same place: understanding the existing system, coordinating with other humans, waiting on decisions. Keystrokes are a rounding error.

You can feel this in your own week. Autocomplete saves real minutes — I'd never give it up — but my hard days were never hard because I couldn't type fast enough. They were hard because the payment service had an invariant nobody wrote down, or because three teams disagreed about what the API should promise. Speeding up the one stage that wasn't slow does almost nothing for total throughput. A factory that stamps parts faster than its inspection line can clear them doesn't ship more product. It ships a bigger pile of parts.

There is one place where typing genuinely is the bottleneck: greenfield work with no existing system to respect. Boilerplate, prototypes, throwaway scripts, the first version of anything. Which is exactly why the demos look like magic — demos are all greenfield, all the time. Production engineering is almost entirely brownfield, and brownfield work is reading work.

Myth 2: AI-Generated Code Arrives Verified

The optimistic version of the workflow goes: describe the task, the model writes it, the tests pass, merge. The flaw sits in the middle step. Tests pass only tells you that the tests you thought to write agree with the code the model thought to write. Both can be wrong in the same direction, and with LLM output they often are — the model produces fluent, idiomatic, confident code, and fluency is exactly what disarms review.

Here's a small example I've seen in the wild, in essence if not in exact form. Ask for a monthly job scheduler and you'll get something like this:

from datetime import datetime
def next_monthly_run(day: int, hour: int = 9) -> datetime:
"""Next run time for a job that fires monthly on `day`."""
now = datetime.now()
candidate = now.replace(day=day, hour=hour, minute=0, second=0, microsecond=0)
if candidate <= now:
# Roll forward one month
month = now.month % 12 + 1
year = now.year + (1 if now.month == 12 else 0)
candidate = candidate.replace(year=year, month=month)
return candidate

Read it the way you'd read a colleague's pull request. It's idiomatic. It handles year rollover. The docstring is even accurate. Now run it on April 15th with day=31: now.replace(day=31) raises ValueError, because April doesn't have a 31st. The function crashes precisely for the most common scheduling request — end of the month — and only during shorter months, so it can sit in production looking healthy for weeks before anyone notices. A test that iterates over a full year of now values catches this in seconds. A careful human reviewer catches it maybe half the time. That gap is the verification problem in miniature.

This is why I keep arguing that in an AI-heavy workflow, the choice between comprehension checks and tests isn't academic — it's the whole ballgame. Reading code you didn't write is already harder than writing it. Reading code that no human wrote, at the volume these tools produce, inverts the economics of review entirely. The teams I talk to aren't short on code anymore. They're short on people who understand what the code does and are willing to sign their name under it.

A magnifying glass reveals a hairline crack across a polished marble slab.
Plausible code fails the way marble fails: along a crack you only see if you look.

Myth 3: Cheaper Code Makes Software Design Cheap

A subtler belief: if code is nearly free, architecture matters less, because we can always rewrite. Bad abstraction? Regenerate it. Wrong data model? Regenerate that too. I've heard senior engineers say this with a straight face, and it confuses the cost of changing text with the cost of changing decisions.

The hard part of software was never the code. It's deciding what's worth building at all, modelling a messy human domain into something a machine can execute, and making architectural bets that won't collapse when requirements shift — and they always shift. These are problems of intent and values, not of pattern completion. A model trained on the corpus of existing software can tell you what systems like yours usually look like. It cannot tell you what yours should look like, because that answer lives in your users, your constraints, and your organization's appetite for risk. On this front we've made essentially no progress, and I'd argue it isn't a capability gap you can scale out of. It's a category mismatch.

Rewrites aren't free either. Most engineering money is spent changing systems that already exist, and changing a system means first reverse-engineering the intent baked into it — the invariants nobody documented, the edge case that turns out to be load-bearing for one important customer. The model doesn't know that intent. Neither, often, does the team. This is the specification-implementation gap where bugs actually live, and generating more implementation widens it unless someone is holding the specification tight.

Fred Brooks had a term for what makes software coherent: conceptual integrity — the sense that one mind, or a few aligned minds, made the decisions. Fluent code generation doesn't move us toward that. If anything, it makes a thousand unaligned micro-decisions cheaper, which is how you get systems that look designed and feel assembled.

Myth 4: Unchanged Software Proves AI Coding Failed

Now the counterpoint, because Blow's framing isn't bulletproof either. Look past mass-market commercial software and things are moving. The indie game scene has produced strategy games with custom engines — from tiny teams — that would have needed Blizzard's headcount a decade ago. More striking to me is the quiet rise of personal software: people building their own email clients, calendar apps, finance trackers, and git frontends, shaped exactly to how they think. These tools are rough and would never survive being shipped to ten thousand strangers. But they exist, they get used daily, and they simply weren't economical to build before.

Even institutions are shifting in ways the headline metric misses. I know of organizations whose modernization plan is, in essence: expose the legacy system through decent APIs and let staff build their own endpoints and interfaces on top with an agentic coding tool. That's not "my software looks the same." That's software dissolving into something more personal — invisible if you're only watching the app store charts.

The deeper reason Blow's observation feels true, though, is organizational rather than technical. Commercial software is shaped by what companies optimize for — engagement, lock-in, release cadence, support cost — and AI gives you more of what you already want, faster. It doesn't change what you want. A company that shipped bloated software because bloat wasn't on its cost sheet will now ship bloated software on a shorter development cycle. The quality bar for software shipped to thousands of users is set by incentives, testing discipline, and taste — none of which are model outputs.

There's also a plain lag argument. Genuinely reliable AI coding is maybe a year old; the period before that was flaky, and before that it was a toy. Products take years to conceive, build, and ship. Judging the effect of these tools on shipped software right now is like judging a new plow by the harvest a month after it was invented.

Myth 5: The Next Model Will Close the Gap

The strongest version of the optimist's case: every objection above describes today's models, and today's models are the worst we'll ever use. Partly true. Context windows will grow, hallucinated APIs will shrink, agents will get better at running their own tests. I'd expect real gains, especially on well-specified tasks.

But notice which bottlenecks are capability problems and which aren't. Verification gets easier as models get more reliable — that's capability. Deciding what's worth building, holding conceptual integrity, changing what an organization optimizes for — those aren't on any model roadmap, because they aren't model problems. And be careful with benchmark progress as evidence: benchmarks miss most of what real work looks like, and real work is precisely the under-specified, intent-laden kind.

So here's my bet, on the record: the tools will get dramatically better for individual builders and small teams with strong taste, and mass-market software will get marginally better, if at all — because the constraint there was never code. If that sounds pessimistic, it isn't. It means the leverage sits in your hands and your org chart, not in a lab's next release.

A gardener prunes a bonsai tree at a sunlit workbench with hand tools.
Software quality is still a tending problem, not a production problem.

What Actually Improves Software Quality

If generation is cheap and verification is dear, the rational response is to shift investment. Concretely:

  • Treat tests and types as production infrastructure. Property-based tests, invariant checks, and fast CI are what turn cheap generation into cheap correct generation. Budget for them like you budget for compute.
  • Write the spec before the prompt. The specification is now the highest-leverage artifact a team produces, because it's the thing the model can't supply and the thing reviewers check against.
  • Use AI where it's genuinely strong: greenfield prototypes, migrations, boilerplate, personal tooling, exploring a design space quickly. Be suspicious of it in load-bearing legacy paths where intent is undocumented.
  • Protect design time. When generation velocity triples, the pressure is to fill the roadmap three times over. Resist it. The deciding is the work.

The bottleneck was never the typing. It was always the deciding — and the proving.

Blow's question has an answer, and it's a hopeful one if you read it right. Software looks the same because software quality was always gated by deciding, verifying, and caring — and AI coding assistants, for all their real usefulness, accelerate the part that was never slow. Which means the tools for making software better are the same tools they've always been: taste, specification, and the discipline to prove things. The models just made it impossible to keep pretending otherwise.