Predicting the future of software has become an extreme sport: the best minds in the industry have been failing at it in public for three years. So before placing my own bets, let's audit theirs — because the mistakes of the people who know the most contain the best clues about what's coming.
First: the prophets' track record
Let's review famous predictions and their actual status as of July 2026:
| Who and when | Prediction | Status today |
|---|---|---|
| Dario Amodei, Mar 2025 | "AI will write 90% of code in 3–6 months" | True inside Anthropic (~90–100%); false industry-wide on that timeline |
| Zuckerberg, Jan 2025 | "In 2025 we'll have AI working as a mid-level engineer" | Not as an autonomous employee; Meta cut 8,000 jobs and moved 7,000 into AI |
| Jensen Huang, Feb 2024 | "Don't learn to code" | Demand for AI-skilled devs hasn't stopped growing |
| Sam Altman, Jan 2025 | "Agents will join the workforce in 2025" | Not as "employees"; yes as omnipresent tools |
| Sundar Pichai, 2024–26 | 25% → 50% → 75% of Google's new code by AI | Came true, on schedule |
The pattern is crystal clear, and it's the key to this whole post: the optimists get the direction right and the timeline wrong — systematically too fast on the social side and too slow on the technical side. Nobody predicted agents would write code this well this soon; everybody overestimated how fast organizations would absorb it.
The number that anchors any serious prediction
If you can only watch one metric, watch METR's: the length of tasks an agent can complete autonomously (at a 50% success rate) doubles every few months — 196 days on the full historical average, but accelerating toward ~3 months in the post-2024 data. In January 2026, the best models completed tasks of ~5 hours of human work; unofficial trackers already place current models above 14 hours.
If the trend holds — and it has held for six years — by mid-2027 we're talking about agents completing tasks worth a week of human work. That single curve explains almost everything that follows.
The coming months (rest of 2026): agentic consolidation
What I consider practically certain between now and December, because it's already underway:
- Orchestration becomes the job. Karpathy named it "agentic engineering" and he was right: the conversation is no longer "which editor do you use" but "how many agents do you direct in parallel." Fleet tooling (dynamic workflows, remote tasks, cloud agents) becomes standard.
- Bill shock. This year's billing changes (Copilot credits, usage limits everywhere) are the symptom: agentic compute cost becomes a serious line item in every team's budget. FinOps tooling for agents will emerge.
- MCP locks in as the universal standard. The July spec (embedded apps, long-running tasks, serious OAuth) plus Linux Foundation governance make it the TCP/IP of agents. If your product doesn't expose MCP in 2027, it doesn't exist for agents.
- Verification becomes the official bottleneck. With benchmarks like SWE-bench saturated (95% for the best model), the problem is no longer generating code — it's reviewing it. 66% of devs say they lose more time fixing "almost right" AI code than writing. That's where the next wave of tools is.
2027: the year of the interface
My central bet for 2027 isn't about code — it's about interfaces. The pieces are already on the table: agentic browsers (Atlas, Comet, Dia) with tens of millions of users, ChatGPT as an app platform with built-in checkout, and WebMCP so sites can expose actions directly to agents.
What that means in practice:
- Your website will have two audiences: humans and agents. Just as mobile-first happened, agent-first is coming: clean APIs, explicit semantics, actions exposed via MCP/WebMCP. A growing share of your "visits" will never see your CSS.
- Generative UI will find its place — which is not everywhere. The dream of "the app is generated on the fly and deleted after" will collide with what Nielsen has warned about for years: an interface that changes every time is an interface no one can learn. The equilibrium: your UI as a reference implementation, with data and actions open so the user's agent can compose its own.
- Agentic commerce becomes normal. With hundreds of millions of weekly assistant users and standardized purchase protocols, "I asked my agent to order it" stops sounding weird. SEO mutates: from ranking pages to ranking actions and data.
💡 If you maintain a web product, the question for 2027 isn't "do I have a mobile app?" but "can an agent use my product without a screen?". Whoever has a good API and good semantics wins the new channel for free.
2027–2028: what happens to programmers
This is where the noise is loudest and where the data says something more nuanced than the headlines:
- The pyramid restructures; it doesn't disappear. Software engineers are now 55% of Big Tech hiring — more than in 2019 (46%). But new grads are only 7% of those hires, half the pre-pandemic share. More senior hiring, less junior: the pyramid is inverting.
- The jobs moved; they didn't vanish. US dev postings are up 14% year over year, but 71% of that increase is senior roles and 37% carry "AI" in the title. Average AI engineer compensation sits around $242K, and agent-focused roles are growing +136% year over year.
- The 2029 shortage is being manufactured today. CS enrollment falling 8% a year, bootcamps closing in waves, companies not hiring juniors. Nobody is training the seniors of five years from now. Concrete prediction: around 2028–2029, a senior-talent-shortage panic and "AI apprenticeship" programs everywhere, hiring juniors again — with a different profile: systems design and verification, not syntax.
- The "because of AI" layoffs will continue — and won't be only because of AI. 2026 has seen ~120,000 tech layoffs with AI as a partial excuse — a mix of real automation, past overhiring and margin pressure. Untangling how much is which will be impossible, and the "AI took my job" narrative will coexist with record demand for engineers who know how to direct it.
2028–2030: the three scenarios
More than two years out, the honest move is scenarios with probabilities, not certainties. Mine:
- Continued acceleration (~35%). The METR curve holds with no ceiling: agents with weeks of autonomy in 2027, a functional "digital employee" toward 2028–29. This is the labs' scenario (though even Amodei and Altman have softened the apocalypse talk this year — curiously, on their way to IPOs).
- Useful plateau (~50%). The one I find most likely. Code generation keeps improving but the hard problems — persistent memory, continual learning, long-horizon coherence — prove stubborn, as Marcus and LeCun warn (LeCun left Meta to found a world-models startup precisely over this). Agents become infrastructure the way the cloud did: transformative, not apocalyptic. "AI 2027"-style forecasts have already slipped to "early 2030s," and Metaculus puts 50% on AGI by 2033.
- Partial winter (~15%). Compute spending doesn't find returns at the promised pace, a hard valuation correction, consolidation. Note: even here, the capabilities already deployed don't go away — nobody is going back to writing CRUD by hand.
My concrete predictions, so I can fail in public
Since I've spent this post auditing other people's predictions, it's only fair to leave mine in writing, dated, so they can be audited:
// Predictions — July 2026 (review in July 2027)
// 1. By Dec 2026: agents reliably complete tasks worth
// ~2 days of human work. [80%]
// 2. By Jun 2027: >50% of new code at tech companies is
// AI-generated (industry average, not just labs). [70%]
// 3. By 2027: at least one top-100 app drops its
// traditional UI for an agentic/conversational one. [60%]
// 4. By 2028: junior hiring recovers in an AI-apprentice
// format after the shortage panic. [65%]
// 5. By 2030: MORE people work in software than in 2025
// (counting the new roles). [75%]
// 6. AGI / drop-in digital worker before 2030. [25%]
The honest closing
Prediction number 5 is the one that really matters, and the one I'm most convinced will come true. Every time the cost of creating software has collapsed — compilers, open source, the cloud — the world didn't want less software: it wanted orders of magnitude more. Software demand has always been supply-constrained, and we just made the supply nearly infinite.
What disappears isn't the programmer; it's the programmer defined as "a person who translates specifications into syntax." What's being born looks more like a systems director who decides, verifies and answers for the result. The next three years will be uncomfortable, uneven and full of exaggerated headlines in both directions. But if I had to pick one moment in history to know how to build software, I'd pick exactly this one.
