Mark Seemann’s blog has spent most of 2026 circling AI, and this post is him answering a reader’s letter in public, with permission, because he says his answers aren’t rigorous — “the situation is so uncertain that I can only answer to the best of my abilities.”

The letter is the part that travels. The reader has no formal CS background and, with LLMs, built a fairly large TypeScript system: APIs, PostgreSQL, LLM pipelines, research automation, multi-model workflows. It felt like magic until he tried to make it a product — fix one error with AI, another appears, then a part behaves in a way he doesn’t understand. His conclusion: “I may have built a system that is above my own level of understanding. When everything works, that gap is almost invisible. When it doesn’t, it becomes very real.”

Seemann’s own position is declared up front: he hasn’t decided on AI but leans toward disliking it, while working with it and finding it impressive — “It’s usually when it impresses me the most that I resent it maximally.” The essay is short on prescriptions and long on uncertainty, which is roughly the point.

What he does argue:

  • If he were starting a career today, he’d seriously consider carpentry, metalworking or gunsmithing — trades where hand-eye coordination still separates people from robots.
  • As an economist, he can’t imagine 30-40% unemployment among knowledge workers leaving the economy intact, and he’s sceptical of the “technology always creates new jobs” argument. New jobs did appear in past transitions, but “often not for those people who lost their jobs. Coal miners didn’t just become programmers overnight,” and the China-shock example created its jobs “just not in the Western world.”
  • On abstractions, the reassuring part: developers have always worked above layers they didn’t understand — web developers didn’t know compilers, compiler writers didn’t know chip design. The old rule of thumb was to understand the level directly below yours and the one above, which was enough to troubleshoot most problems.
  • On speed, the deflating part: LLMs make directed questions cheap, but he doubts human learning speeds up much, because “the bottleneck is hardly the teachers nor the materials, but how fast a human brain can absorb new knowledge.”
  • On his own practice: he doesn’t use LLMs for learning. “LLMs don’t hallucinate; they bullshit,” he writes, and he’ll only ask them falsifiable questions — “Can I make this Haskell expression more succinct?” — never “What should I learn next?”

The essay ends without a program, which leaves the thread to argue about whether one exists. The 120-comment thread on Hacker News supplies what the essay deliberately withholds.

What the thread adds

  • japhyr — independent corroboration, and the reason this reads as a moment rather than a one-off: the author of Python Crash Course got “this exact same email this week,” and is planning a public response for the same reason. On the core question, they’re unambiguous: “Absolutely. That’s the core of this person’s email.” LLMs now let someone build an MVP “that goes well beyond your own understanding of the implementation” — so the skill becomes deliberately building understanding while you build. senko pushes back on the drama of “just five years ago”: you never needed to understand TCP sockets or B-trees either, the missing rung just moves up.
  • agentultra — the blunt prescription this thread keeps circling: “you have to be able to program it yourself before you can build it with an LLM. Otherwise you have no way of judging the output.” Their advice is the old, slow route — “There’s no royal road to knowledge, skill, and learning.”
  • aethertap — the most concrete method in the thread, from someone teaching his own kids: keep a handmade project going with no AI assistance even if it’s painfully slow; when using a model, treat it as a compiler over data structures, algorithms and architectural requirements rather than as a source of code; and when a bug appears, write down your own hypotheses first and only then let the model investigate how close you came.
  • bborud — the operational failure mode, without any philosophy attached: Claude went down during a frantic initial production deployment at a friend’s company, “and suddenly nobody was able to do anything. Because nobody had actually read the code and had no idea how it worked.”
  • duendefm — the double-edged-tool argument from someone doing systems and telephony work alongside juniors: AI speeds you up and slows you down, and “the more you use it as an oracle, the less competent you get.” Their worrying case is juniors who produce impressive-looking work and can never become experts “if they get stuck in the AI using loop.” bigfishrunning replies with the counterpart complaint — an engineer writing slow, careful, well-structured code watching colleagues “produce unmaintainable slop at an alarming rate” and feeling like the industry is dying.
  • AnodicElegy — the thread’s substantive disagreement with the essay, aimed at the China-WTO analogy: US unemployment “peaked soon after, decreased to well below the point it had been at China’s entry,” which they read as support for replacement rather than displacement. wuisce defends the narrower point Seemann actually made — the new jobs didn’t go to the workers who lost theirs, which is why the Rust Belt and northern England were devastated.
  • js8 — the philosophical objection, via Curry-Howard: programming languages are notations for formal logic, and natural language is a worse substrate for maintaining programs. Their kicker: “we already have automated programmer — it’s called a compiler.” jeremyjh corrects the framing in a reply — LLMs don’t execute natural language, they generate and test formal logic they predict will satisfy the request.

Where the thread splits, and what it keeps asking

The split is whether foundations can be learned while shipping, and it doesn’t resolve. agentultra and Barrin92 say no: the reader “outsourced the building of a product,” and you could “replace the word ‘model’ in the article with ‘guy I hired on fiver’ and there would be no difference.” japhyr and dack say yes, with discipline — build real things, then dig into the code with the model until you understand it, treating the bug you just hit as the curriculum. Trusteando raises a fair question about the format itself: a veteran who learned in the 1990s “can perhaps give you only one side of the coin,” and someone learning from scratch today would show the other. travthedev asks the version of it that never gets a clean answer: how much programming knowledge is enough before you can call yourself a solo developer?

Not everyone in the thread sees a crisis. asp_hornet reports the opposite experience — bugs caught earlier by AI review, more and better tests, faster shipping, less bikeshedding — and lolakutty gets four replies’ worth of argument from one line: “Sorry, programming is still fun. LLMs can’t change that.” And cortic quietly deflates the central confession: “I feel like that about a lot of code i did myself” — a few months or years is enough to forget your own system, AI or not.

A note on reading comments as evidence: HN handles are pseudonymous and the site publishes no per-comment scores, so the ordering here is HN’s own ranking, not a vote. This is a slice of the thread, and disagreements are quoted as disagreements.