Carson Gross teaches computer science at Montana State University. He created htmx. His sons know he's a programmer. People keep asking him whether programming is still worth learning given AI. His answer — 'Yes, and…' — is the most grounded, least panicked, and most practically useful take on this question currently in circulation. The core argument is deceptively simple: programming is problem-solving plus complexity management, and neither of those skills is going away. But Gross is not naïve about what AI changes. He identifies the precise danger for juniors: if you let the LLM generate code you never learned to write, you lose the ability to read code — and reading is the skill that matters most in an AI-augmented future. He calls this The Sorcerer's Apprentice Trap, and the metaphor lands because it's structurally accurate, not just vivid. Gross dismantles the popular analogy that coding-to-prompting is like assembly-to-high-level-languages. His rebuttal is clean: compilers are deterministic, LLMs are not. High-level languages eliminated accidental complexity; LLM-generated code often adds it — wrong abstractions, inappropriate shortcuts, cargo-culted patterns. If you can't read the output, you can't tell the difference between necessary and accidental complexity. This is the essay's sharpest insight and the one most likely to age well. The 'and…' section maps what rises in value as raw coding falls: communication skills, business understanding, system architecture, and effective LLM use. None of this is revolutionary, but Gross earns these observations by grounding them in specific practice. He shares his own LLM usage patterns — analysis, organization, small code generation, tests — and draws a hard line: he never lets LLMs design his APIs. That specificity is what separates this from a hundred LinkedIn posts making similar noises. The essay's most generous move is the AGENTS.md file Gross provides to students, configuring coding agents to behave as TAs rather than code generators. This is pedagogy, not polemic. He acknowledges that juniors face real workplace pressure to vibe-code fast, and doesn't pretend that principled slowness won't cost them in the short term. But he bets — and it's clearly a bet, not a certainty — that companies will eventually realize vibe coding produces worse complexity explosions than deliberate, understood code. What holds the piece back from essential status is its middle section, where the 'and…' recommendations (read books, understand business, improve communication) flatten into advice that could appear in any career-guidance essay from the last thirty years. The essay is strongest when Gross is specific and weakest when he's general. The architecture section gestures at the catch-22 of AI-era skill development — you need experience building small things to architect big things, but AI wants to build the small things for you — without fully resolving it. Still, this is an essay that treats its audience as adults, offers concrete tools alongside philosophy, and resists both AI doomerism and AI hype. Gross writes like a person who actually codes, actually teaches, and actually thinks about what he's asking students to do. That combination is rarer than it should be.
