AI can write code now — do we still need programmers?

This question isn't new — it's been asked since the first compiler. But this time is different, because AI isn't just "making things easier" — it's changing who writes code and what gets written. I'll answer it with real, measured data — not feelings or hype. Every number has a source.

Note: this article compiles findings from real research and reports as of November 2026. Numbers change fast, and predictions are always uncertain. What's presented is "what we know now," not prophecy.

1. The real data: how good is AI at writing code, actually?

1.1 Adoption — it's real, and it's everywhere

• Stack Overflow Developer Survey 2025 (49,000+ devs, 177 countries): 84% use or plan to use AI tools, up from 76% in 2024
• GitHub Octoverse 2026: reported that over 40% of pull requests on GitHub now start with an AI agent (up from ~17% in March 2026) — an adoption indicator, not proof humans aren't needed

1.2 Trust — heavy use, but trust is falling (this is the interesting part)

This is what most people don't realize — adoption is high but trust is dropping:

• Stack Overflow 2025: distrust (46%) exceeds trust (33%) — just 3% "highly trust" AI output, and overall confidence in accuracy fell from ~40% to roughly ~29–33%
• Devs with 10+ years' experience trust it least — only 2.6% highly trust
• 66% of devs say they spend more time fixing "almost-right" AI-generated code
• 45% complain about "AI solutions that are almost right, but not quite"
• 75% say they'd still ask a person when they don't trust AI

1.3 Productivity — the research contradicts itself (here's the truth)

This is the part people cherry-pick. I'll put both sides side by side:

• GitHub Copilot study (2023, arXiv): 95 devs wrote an HTTP server in JavaScript — the Copilot group finished 55.8% faster. But — single task, tests provided in advance, freelance devs, and code quality over time wasn't measured
• METR RCT (July 2025) — the stricter study: 16 experienced devs (repos averaging 22k stars, 1M+ LOC) completed 246 real tasks randomly assigned — the AI group was19% slower, even though everyone predicted AI would be 24% faster beforehand, and still believed afterward they'd been 20% faster
• Deeper METR findings: devs accepted AI code unmodified less than 44% of the time; time went to "reviewing AI output + prompting + waiting" more than to actually writing
• Accenture RCT with GitHub: enterprise devs reported better productivity — but it's self-reported, not objective measurement

Honest summary: AI is faster on well-defined tasks with clear tests and unsophisticated codebases — but on real, complex work the latest rigorous research suggests it can be slower due to review/prompting overhead. The truth is in the middle — it depends on the task, experience, and how it's used, not one universal number.

1.4 The labor market — the numbers that actually matter

• Stanford Digital Economy Lab (Brynjolfsson et al., using ADP payroll data): employment of software developers aged 22–25 fell ~20% from its late-2022 peak — the authors call them "canaries in the coal mine"
• SignalFire: Big Tech new-grad hiring -25% (2024 vs 2023), startups -11% — while hiring of devs with 2–5 years' experience rose
• NY Fed: CS bachelor's unemployment ~6% (above the overall ~4% and above majors like nursing)
• Challenger Gray & Christmas: ~1.2 million US job cuts announced in 2025 (highest since 2020) — tech hit hardest at 154,000+, but AI was directly cited for only ~55,000 (≈4.5%) — AI isn't the main layoff driver yet
• UK (NFER, Adzuna data): software developer employment fell for the first time since 2006; programmer job adverts fell ~68% (2019/20 vs 2024/25)
• Europe/US (Indeed, Oct 2025): tech job postings below pre-pandemic levels — UK -41%, France -39%, US -35%, Germany -30%
• WEF Future of Jobs: 40% of employers plan to cut staff in areas AI can automate

2. Short term (1–3 years): what actually changes

• Junior devs are hit hardest — entry-level work (CRUD, boilerplate, simple tests) is exactly what AI does best. New-grad hiring is genuinely shrinking
• Senior devs remain in demand — work requiring judgment (architecture, trade-offs, security, legacy code) is still beyond AI. Review/decision roles grow
• The role shifts: from "writing" to "supervising" — prompting, reviewing, verifying, integrating — judgment work
• Tools change — old-school IDEs will fade; devs fluent in AI tools will outproduce those who aren't
• Junior pay may compress — but total developer demand isn't disappearing

3. Long term (5–10 years): three plausible scenarios

I don't know the future, but the data supports three scenarios:

• Scenario A: AI as a very good copilot (most likely) — AI writes 70–90% of boilerplate; devs handle architecture, review, edge cases → demand drops ~30–40% but remaining roles pay more. Like the compiler era — it didn't kill programmers, it ended "writing every line yourself" as the main job
• Scenario B: AI gets good enough to shrink devs massively — like assembly→C→Python but faster — demand falls 50–70% in 10 years, but people are still needed to design systems, define requirements, own outcomes — fewer devs, higher average quality
• Scenario C: human bottlenecks persist — while the trust gap remains (29% today) and regulated industries (banking, healthcare, government) require human accountability — devs remain necessary, but the role becomes "AI supervisor + domain expert"

What every scenario agrees on:"Programmers who write every line themselves" will shrink — but "people who understand systems and own outcomes" will still be needed. The difference is in skills, not in whether work exists.

4. Universities and education: what needs to change

The enrollment data is striking:

• National Student Clearinghouse (US, fall 2025): CS undergrad -8.1%, graduate -14.0% — first decline in years (Data Science/Analytics growing instead)
• CRA Taulbee Survey 2025 (North America): new CS majors -12.9%, bachelor's enrollment -3.1%, master's -24.9% — the pipeline is slowing
• UC system: CS enrollment fell for the first time since the dot-com crash (-6% system-wide; UC Berkeley's CS major -21% — though counting EECS + Data Science together it's still growing). It's not just AI: Berkeley saw applications rise 25% but seats are capped
• Interpretation caveat: part of the decline is likely a correction from the pandemic peak, and AI is not the only cause — the numbers show "choices are changing", not "why"

Majors worth adapting toward:

• Traditional Computer Science — still valuable, but must add AI/ML engineering, systems design, security, data engineering — not just "teach coding," because that part is already handled by AI
• Data Science / AI Engineering — fastest growing now (+33.5% BLS projection) — but needs math + domain knowledge, not just prompting
• Software Engineering — more emphasis on design, testing, DevOps, architecture; less on pure syntax/algorithms
• Cybersecurity — keeps growing as AI expands the attack surface; needs more security-aware people, not fewer
• Applied engineering (electrical, mechanical) — rising, because it requires understanding the physical world AI still can't touch
• Domain-specific (finance, healthcare, legal tech) — people who know tech + a domain will be rare and well-paid; AI writes code but doesn't understand niche business rules

What universities should do (and mostly haven't yet):

• Teach "working with AI" as a core skill — prompt engineering, reviewing AI output, verification
• Emphasize systems thinking, architecture, debugging — what AI still can't do well
• Add project-based learning that uses AI tools for real — don't ban them, because workplaces use them
• Teach ethics/responsibility for AI-generated code — because devs will be accountable for what AI writes

5. The main question: do we still need / hire programmers?

Short answer: fewer per unit of work — but total demand is still growing.

• BLS 2024–2034: software developers +15.8% (267,700 new jobs), data scientists +33.5%, information security analysts +28.5% — still growing
• But computer programmers (the legacy title) are projected to decline ~7% in the latest outlook — "pure coding" work shrinks while software engineering grows
• What's disappearing isn't devs — it's "devs who only write code." Demand is shifting to people who do more: design, review, integrate, decide.

For organizations:

• Don't lay off all devs expecting AI to replace them — research shows AI helps in some tasks but needs human review
• Adjust hiring: hire fewer juniors doing only CRUD — more seniors doing architecture + AI oversight
• Invest in AI tools + training — devs who use AI well are more productive
• Watch security — AI-generated code has vulnerabilities that need auditing

6. Real advice (not hype)

For new devs:

• Learn "working with AI" from day one — not learning instead of AI
• Focus on systems, architecture, debugging — what AI still can't do well
• Build a portfolio showing "review + integrate" ability, not just "writing"
• Prepare to be an "AI supervisor" — judgment work

For experienced devs:

• Use AI tools seriously — not dabble, but integrate into workflow
• Develop skills AI still can't: legacy code, complex debugging, security audits, performance optimization, architecture decisions
• Mentor juniors — they'll be rarer and more valuable
• Build domain knowledge — tech + business people will be scarce

For organizations:

• Don't fear AI — use it as a force multiplier
• But don't think AI replaces devs entirely — the 71% trust gap still exists
• Invest in training devs to use AI tools well
• Watch the junior pipeline — if you stop hiring juniors entirely, in 5 years there won't be good seniors

7. Summary: the truth we have to accept

AI can write code well now — on well-defined tasks it's faster and good enough. 84% adoption isn't hype.

But "writing code" ≠ "doing software engineering" — trust is only 29%, 66% of devs must fix AI code, METR proved experienced devs can be 19% slower on real work — the gap between "generate code" and "ship correct software" is still wide.

The labor market is genuinely shifting — junior jobs shrinking, seniors still needed, CS enrollment falling — but this is "reshaping," not "disappearing." Like the calculator — it didn't kill math; it changed what "good at math" means.

The final answer:We still need programmers — but "programmers" in 2030 won't look like "programmers" in 2020. They'll be people who understand domains, design systems, review AI output, and own quality — not just write syntax. If you or your team adapt — AI is an opportunity. If you don't — it's a threat.

And for those choosing a major — don't pick "a major AI can't do" (none exist anymore). Pick "a major AI can do + you can do better" — learn to work with AI as a tool, not to compete with it.