A Hacker News post titled “Coding expertise is going to collapse from AI reliance” hit 530 points and 520 comments in 24 hours. The author, Lars Faye, argues that AI coding tools are removing the friction necessary to build genuine expertise — and developers showed up in force to debate it.
Simultaneously, another thread — “Ask HN: Coding is a solved problem. What is left for experienced engineers?” — captured a different angle: an experienced engineer’s existential crisis after realizing their hard-won implementation skills are now commoditized.
Together, these threads reveal a profession in transition. Here’s what developers actually think.
What Happened: Two Threads, One Crisis
Thread 1 started with a blog post arguing that LLMs remove the “productive struggle” that builds expertise. The analogy: just as calculators let students skip arithmetic, AI agents let developers skip the implementation grind — but arithmetic was never the point of math, and implementation was never the point of engineering.
Thread 2 was a personal cry for help. An engineer with years of experience wrote: “I spent that time building, learning, and trying to get better. Looking back now, much of it feels like time spent getting better at a problem that has already been solved. And so I have come to a harsher conclusion: I wasted a lot of that time.”
The responses ranged from “you’re having a midlife crisis” to “you’ve identified the inflection point.”
Developer Reactions: The Battle Lines
Camp 1: “This Is Just the Calculator Argument Again”
The most upvoted comparison: calculators didn’t destroy math skills — they shifted the bottleneck to higher-level concepts.
“Math skills are at their lowest point ever in modern society, and many are still advocating for the reduction in reliance on calculators for this reason.” — larsfaye
But the counterargument was sharp: a calculator doesn’t take over executive function.
“Not really the same, since your average calculator doesn’t take over executive function. The user thought and decided what needs to happen, down to one extremely well-specified task… This is more like paying someone else to read your math homework, generate answers, and maybe even submit them on your behalf.” — Terr_
Several developers noted that the Mathematical Association of America still bans calculators in competition — suggesting the “calculator analogy” defenders might be ignoring active institutional pushback.
Camp 2: “The Junior Pipeline Is Already Broken”
This was the most visceral thread. Multiple commenters described a hiring crisis happening right now:
“Junior engineers are not low value and thus low wage anymore, they are highly negative in value… Before they would puzzle on something for days and finally come back with a small PR that kind-of worked but needed revision. Now they can puke out 50,000 lines of code that they don’t understand in 3 hours.” — ltbarcly3
The economic logic: companies can’t afford to train juniors when those juniors generate negative-value code that seniors must untangle. The pipeline dries up → senior supply shrinks → salaries spike → earlier retirement → death spiral.
“By the time governments and the industry are feeling enough pain to do something about this salaries will be out of control.” — ltbarcly3
Camp 3: “Guided Coding > Vibe Coding” — The Practitioner’s Middle Path
A surprising number of experienced engineers rejected the binary (manual vs. autonomous) and described a third way: guided coding with fast models.
“I have over 15 YoE writing software and guided coding sessions… is as productive as vibe coding, produces significantly higher quality, is actually enjoyable, and you actually stay sharp.” — mrheosuper
The key insight: flash models (DeepSeek v4, Qwen 27B) are fast enough to keep you in the loop. You prompt → review → veto → re-prompt in a tight cycle. No 40-minute thinking pauses. No unreviewable 50k-line black boxes.
“Flash models tend to be so fast that you don’t have time for parallel agents, you lock in and rapid fire prompts, building high quality software while incrementally reviewing it as you go.” — mrheosuper
This camp argues the tooling choice matters more than the philosophy. Frontier models (Claude Opus, GPT-4o) encourage “delegate and pray.” Flash models encourage “steer and verify.”
Camp 4: “Code Quality Is Now the Moat”
Multiple commenters observed that AI amplifies codebase quality differences exponentially.
“My experience is that AI has significantly boosted the value of a quality code-base. A good codebase essentially codes itself… If implementing a feature requires a huge amount of tokens, then there’s a good chance the codebase is not great.” — socketcluster
One engineer measured this: 3k tokens vs 30k tokens for the same feature complexity depending on architecture. The “token cost of a feature” became their new code quality metric.
“It’s not about the size of the project; it’s more about how the logic is divided and the architecture. And importantly; it’s not a one-off; it’s a clear observable, repeatable pattern.” — socketcluster
Camp 5: “The ‘Solved Problem’ Engineer’s Existential Crisis”
Thread 2 revealed a distinct psychological profile: engineers who tied their identity to implementation difficulty.
“Before LLMs, I saw a lot of value in it. Building things was how I learned, found gaps in what I knew, and proved to myself that I could take something from an idea to a working system… Now it feels different. A lot of that work can be done with a few prompts… That is the part I am struggling with. It feels like years of hard-earned advantage disappeared very quickly.” — gokuljs (OP)
Responses split:
- Reframers: “Craftsmanship will no longer live in code going forward. Instead, it will live somewhere else… I strongly suspect it will still be part of the profession.” — rl3
- Skeptics: “From what I can tell we ain’t actually there yet… my human perspective and input is everything that keeps my stuff from going generic.” — herbst
- Product-focused: “You need to build a product mindset muscle! Coding IS a solved problem! Building a winning product and architecting it is NOT!” — krishnas2020
The Real Insight: Three Inflection Points
Reading 500+ comments, three under-discussed inflection points emerge:
1. The “Token Budget” Is the New Code Review Metric
Teams are discovering that token consumption per feature correlates with architectural health. A well-factored codebase lets an agent make surgical edits (low tokens). A tangled one forces the agent to read entire files, grep endlessly, and produce verbose patches (high tokens).
This is measurable today. No speculation needed.
2. The “Flash Model” Workflow Is Being Undersold
The industry narrative pushes frontier models + autonomous agents. But practitioners doing daily work have converged on small, fast, cached models + tight human-in-the-loop cycles.
This isn’t a compromise — it’s a different paradigm that preserves agency and code quality. The tooling (Zed, OpenCode, custom setups) matters more than the model brand.
3. The Junior Crisis Is a Management Crisis, Not a Tech Crisis
The “negative value junior” problem exists because management expects juniors to produce production code immediately. Historically, juniors did “shit shoveling” — low-risk, high-volume work that built intuition. AI automated that tier.
The solution isn’t “ban AI for juniors” (Uncle Bob’s suggestion). It’s restructure what junior work looks like — code review, testing, documentation, architecture shadowing — and accept that the apprenticeship model must change.
What It Means for You
If You’re a Junior or Aspiring Developer
- Don’t avoid AI — that makes you unemployable
- Don’t delegate blindly — that makes you replaceable
- Learn the “guided coding” loop: prompt → read diff → veto → re-prompt
- Study codebases, not syntax: the token-cost metric means architecture reading > syntax memorization
- Build an “agent portfolio”: show you can steer agents to production outcomes, not just generate snippets
If You’re a Senior Engineer
- Your leverage shifted: from writing code to designing the guardrails agents operate within (SKILLS.md, AGENTS.md, test suites, architecture)
- Token budgets are your new code review tool: if a feature costs 30k tokens, the architecture is the bug
- Mentorship is now “agent supervision training”: teach juniors how to verify, not how to type
If You’re a Team Lead / Hiring Manager
- Stop hiring for “coding speed” — AI commoditized that
- Hire for “architectural taste” and “verification rigor”
- Redefine junior roles: code review, test design, documentation, agent orchestration — not feature implementation
- Measure token-per-feature across your codebase; it’s your new technical debt dashboard
If You’re Building Tools
- Flash models + tight loops > frontier models + long horizons for daily work
- Observability > autonomy: developers want to see what the agent is doing in real-time, not get a finished PR
- The “addressable document” problem is real: GEML, Markdown addressing, context retrieval — this is the next tooling frontier
The Uncomfortable Truth
The most honest comment in the entire thread:
“Hell, critical thinking in general will collapse. I mean, even more than it already has due to easy access to the internet. Thinking through a problem is hard. For the most people will take any chance they can get to not think. Myself included. I probably gain double digits of IQ when my internet goes down.” — somat
AI coding agents didn’t create the avoidance-of-thinking problem. They accelerated it into the core workflow.
The developers who thrive won’t be the ones who “use AI the most” or “use AI the least.” They’ll be the ones who build friction back in deliberately — guardrails, verification loops, architectural constraints — because they understand that expertise lives in the friction you choose to keep.
This article synthesizes developer opinions from Hacker News threads 49421554 and 49429899 (August 2026). All quotes are paraphrased from real comments. Original threads contain 560+ total comments.