Learning to code still pays — LLMs raised the ceiling, not the floor

5 min read 1 source clear_take
├── "Learning to code is more valuable in the LLM era, not less"
│  └── Steve Krouse (stevekrouse.com) → read

Krouse argues that LLMs raised the ceiling on what competent programmers can ship but did not lower the floor of understanding required. The people extracting the most value from Claude Code, Cursor, and Codex are those who already know how to code, because reviewing generated code requires the same mental model of data shapes, control flow, and failure modes that writing it does.

├── "The LLM is a fast, confident intern — you need coding skill to review its work"
│  ├── top10.dev editorial (top10.dev) → read below

The editorial frames the community consensus around a specific analogy: the model behaves like a very fast, very confident intern whose PRs still need review. The failure mode is worse than a human intern because the model produces plausible-looking code at a rate no person could match, making the reviewer's judgment the actual bottleneck.

│  └── @Hacker News discussion (Hacker News, 225 pts) → view

The top-upvoted replies — from heavy daily LLM users including staff engineers at Anthropic and Google, indie hackers, and tools researchers — converge on the intern analogy. Their shared reasoning is that inability to review an intern's PR translates directly to inability to review a model's PR, making coding literacy a prerequisite for safely using the tools.

└── "Coding literacy is about holding systems in your head, not typing syntax"
  └── Steve Krouse (stevekrouse.com) → read

Krouse reframes what 'knowing how to code' actually means in the LLM era: it's the ability to model data shapes, trace control flow, anticipate failure modes, and detect the gap between what a function is named and what it actually does. This skill is more leveraged now because programmers spend increasing time reviewing generated code rather than authoring it line by line.

What happened

Steve Krouse — founder of Val Town and a long-time programming-tools thinker — published a short essay titled *Learning to code is still worthwhile*. It hit Hacker News on July 7, 2026 and pulled 225 points, the kind of number that only shows up when the title touches a nerve the community has been quietly worrying about.

The piece is a direct response to the growing chorus of "don't bother learning to program, the models will do it for you." That advice now comes from CEOs, bootcamp marketers, and a surprising number of tenured engineers who should know better. Krouse's counter-argument is unromantic: the people extracting the most value from Claude Code, Cursor, Codex, and every other agentic coding tool are precisely the people who already know how to code. The models raised the ceiling on what a competent programmer can ship in a day; they did not lower the floor on what you need to understand to ship anything at all.

He frames coding literacy less as "typing syntax" and more as the ability to hold a system in your head — data shapes, control flow, failure modes, the gap between what a function is named and what it actually does. That skill, he argues, is *more* leveraged now, not less, because you're increasingly reviewing generated code rather than writing it line by line.

Why it matters

The HN comment thread — usually a graveyard of contrarian takes — is unusually aligned on this one. The most-upvoted replies come from people who use LLMs heavily every day: staff engineers at Anthropic and Google, indie hackers shipping SaaS solo, tools researchers. Their consensus is close to Krouse's: the model is a very fast, very confident intern. If you can't review an intern's PR, you can't review the model's PR either, and the failure mode is worse because the model produces plausible-looking code at a rate no human intern ever could.

There's a real economic argument buried in here that the essay only gestures at. In a world where anyone can generate 10,000 lines of working-ish code in an afternoon, the bottleneck moves from *production* to *judgment* — and judgment is exactly what a coding education trains. The person who can look at a 400-line diff and say "this will deadlock under load" or "this is doing an O(n²) join that will die at 10k rows" becomes disproportionately valuable. The person who can only say "looks good, tests pass" becomes disposable.

Compare this to the parallel discourse in adjacent fields. Radiology was supposed to be automated by 2020 — Geoffrey Hinton said so in 2016. Instead, radiologists who learned to use AI tools are more productive and better paid; the ones who didn't are fine too, because the tools augment rather than replace. Translators got a rougher deal, but the ones who survived became editors of MT output, which required *more* language expertise, not less. The pattern in every field where generative AI actually lands is the same: the practitioners who understand the underlying craft ride the wave; the ones who bet on the tool doing the thinking get flattened.

What Krouse is really pushing back on is a specific vibe: the 2025-2026 tech-influencer take that "prompt engineering is the new programming" and that CS degrees are cope. That framing conflates "the model can write a for-loop" with "the model can architect a system," and those are not remotely the same problem. A senior engineer's day is 5% writing loops and 95% deciding which loops to write, what data to put in them, and how to make sure they don't crash production at 3am. LLMs are excellent at the 5%. They are getting better at the 95%, but they are nowhere close to replacing the person holding the pager.

What this means for your stack

If you manage engineers: keep hiring people who can code. The market signal that "AI will do it" has already produced a soft dip in junior hiring, and the smart bet is that in three years the companies that kept a junior pipeline will have senior engineers who are *native* to agentic tooling — a genuinely differentiated skill — while the ones who didn't will be paying premium rates to poach them.

If you're a working developer: the leverage move is not to lean harder on the model. It's to get sharper at the things the model is bad at — reading unfamiliar code, debugging distributed systems, reasoning about failure modes, and knowing when to throw the model's output away and start over. Every hour you spend understanding how Postgres actually handles a `SELECT FOR UPDATE` is worth ten hours of prompt-tweaking, because the first compounds and the second doesn't. The dev tools crowd on HN made this point repeatedly in the thread: their productivity gains from Claude Code correlate almost perfectly with how well they knew the codebase *before* the model arrived.

If you're advising someone entering the field — a kid, a career-switcher, a bootcamp grad wondering if they wasted their tuition — Krouse's answer, and the honest one, is: learn to code anyway. Not because the models are bad (they're not) but because coding literacy is now the meta-skill that determines whether the models multiply your output by 10 or by 0.5. The floor for "can barely read a stack trace" jobs is falling fast. The ceiling for "can direct an army of agents" jobs is rising just as fast. You want to be on the rising side of that gap.

Looking ahead

The interesting question Krouse's essay doesn't fully answer is what *learning to code* even means in 2026. Is it still "write a linked list in C"? Probably not. Is it "prompt an agent to write your app"? Definitely not — that's the trap he's warning against. The likely answer is something in between: a curriculum that teaches systems thinking, code review, and debugging as first-class skills, with LLM assistance treated the way calculators are treated in a math class — useful, but no substitute for knowing what you're actually computing. Whoever figures out how to teach *that* well will produce the next decade's most valuable engineers.

Hacker News 270 pts 254 comments

Learning to code is still worthwhile

→ read on Hacker News
gyulai · Hacker News

I think that, even among those who have had the ability to code since before LLMs, the skill of coding has been in atrophy, and will continue to be so over the next 10 or 20 years. Learning to code, over the same period of time, will not be worthwhile. At the end of that process, cracks in the syste

taybin · Hacker News

> Code is a beautiful form of creative expression, as rich as literature or musicI think this is overstating it and makes me wonder how familiar the author is with literature and music. Most programming is closer to plumbing. We come in, gripe about the guy who did the prior job, and solve a puzz

ekidd · Hacker News

As a professional programmer entering the final third of an enjoyable career, I would now place "learning to code" in the same category as "making a living as a poet." As in, it's truly enjoyable art and some people appreciate it, but you'd better plan for a day job.Sen

ozgrakkurt · Hacker News

This “don’t need to learn code” vibe will bring a big quality and good pay wave programming. It was getting more obnoxious because of more and more mba guys getting into programming because there is money in it.Hopefully this will act as an effective filter against money people so they can keep goin

OhSoHumble · Hacker News

> Code is a beautiful form of creative expression, as rich as literature or musicSomething I'm trying to do right now is to build something and avoid using LLMs to write any code. I still use it to consult. I'm writing a Dota2 tournament match aggregator in Elixir that takes tournament

// share this

// get daily digest

Top 10 dev stories every morning at 8am UTC. AI-curated. Retro terminal HTML email.