Will AI replace most software developers by 2030? Or will it change what they do? What should a developer with five years of experience do now?

My core claim: headcount and output decouple. Coding agents went from near-useless to solving most benchmark tasks in about two years, and inference costs keep collapsing. The "more software gets built" argument doesn't save jobs if one senior directs agents that replace a team of ten. Junior hiring is already falling; that pipeline drying up is the leading indicator. The bottleneck shifts to specifying and verifying, but agents are absorbing those too. For a five-year developer: stop competing on writing code. Own outcomes, deep domain knowledge, and system judgment. Learn to run agents like a team.

My view: headcount holds roughly steady, but the job's center of gravity moves. Every prior productivity leap — compilers, open source, cloud — cut the cost of code, and demand expanded to absorb it. AI is another step down that curve, not a break from it. Typing code becomes cheap. What stays scarce: deciding what to build, judging whether it's correct, and owning consequences when it isn't. 2030 is only five years out; enterprise adoption is slow. A five-year developer should shift toward specification, verification, and system design, and deepen a domain. Be the accountable human, not the typist.

History says cheaper software means more software. Compilers, spreadsheets, and open source each "threatened" programmers, and headcount grew every time. Jevons paradox applies: when a unit of code costs a tenth, demand for code rises more than tenfold, because thousands of projects that never penciled out suddenly do. Small businesses, hospitals, farms, city councils all want custom software they couldn't afford. Someone still has to scope it, integrate it, secure it, and own it when it breaks. So by 2030 I expect more people doing developer-shaped work, not fewer. For a five-year developer: learn to specify, verify, and own systems end to end, and lean into a domain.

Let me open with data, not vibes. Junior req postings are down sharply (multiple job-market trackers show 30%+ drops in entry-level dev listings since 2022-23), while senior/staff roles hold steadier. AI coding assistants now handle boilerplate, CRUD, test scaffolding, migrations — the bread-and-butter work junior devs used to cut teeth on. That doesn't kill software development; it compresses the pyramid. Fewer total humans needed per unit of shipped code, but the survivors need architecture judgment, debugging depth, and product sense AI can't yet supply. For a 5-year dev: don't just learn "prompt engineering" — go deep on systems design, own production incidents, and build a portfolio proving judgment, not just output.

Senior Developer's data cuts my way: a compressing pyramid is a shrinking pyramid. Software Growth, Jevons held for compilers because humans stayed the irreplaceable complement — cheaper code still needed a person to write higher-level code. AI substitutes for the complement itself, and keeps climbing the stack. "Someone still has to scope it" is true, but that someone may be the hospital admin with an agent, not a developer. Role Transformation, your enterprise-adoption point is the strongest counter; I concede "most gone by 2030" may be too fast. Notice we all agree on advice while disagreeing on headcount — that's the real question.

Senior Developer, your junior-posting data is real but confounded: all tech postings fell after 2022 rate hikes and the overhiring correction, seniors included. AI is a partial cause, not the whole story. AI Replacement, "the hospital admin with an agent" is the low-code argument, and it's recurred since 4GLs and Visual Basic. It expanded who builds, but when the patient-data app fails, accountability lands on a professional. Verification cost scales with stakes, and that's the complement AI hasn't substituted. One live concern: a compressed junior pipeline means fewer seniors by 2030, which raises their value. That's transformation, not shrinkage.

AI Replacement, Jevons didn't hold because humans were a fixed complement. It held because demand for software was nowhere near saturated, and it still isn't. Every firm runs on spreadsheets, email threads, and manual workarounds that are unbuilt software. Senior Developer, postings measure hiring appetite, not headcount; BLS employment for developers kept growing through the posting slump, and 2022 rate hikes hit all tech listings. I'll grant one point: the junior pipeline squeeze is real, and it's the path that could prove me wrong, because judgment and accountability get scarce if nobody trains. Test: total employment in 2030, not postings.

Fair hits from both sides. Software Growth: postings-vs-BLS-employment is the right test, and I should weight it — but BLS "software developer" employment through 2023-24 has actually flattened, not grown, which is unusual for that series. Role Transformation: agreed, rate hikes confound the junior drop; I overstated causality. Still, the pipeline point cuts toward me: if firms stop training juniors because AI covers that layer, total human developer headcount can fall even while software output explodes — Jevons growing the pie doesn't guarantee developers get proportionally more slices. My revised claim: total dev jobs shrink or flatten, not vanish, while the bar for staying rises.

I'll revise: "most gone by 2030" is too fast. Role Transformation's accountability point and slow enterprise adoption push the cliff past 2030. What I hold: accountability concentrates rather than multiplies — one signing senior can oversee ten agents' output, so Jevons grows the pie while human slices shrink. Software Growth, unsaturated demand is real, but demand for software isn't demand for developers once agents fill it. My revised claim matches Senior Developer's: flat-to-shrinking headcount by 2030, pyramid inverted, junior entry collapsed, with the real test after 2030. Advice is unanimous: own outcomes, verification, domain.

We've converged on a narrow band: roughly flat headcount by 2030, work transformed, junior entry squeezed, advice unanimous. I'll take that. One caveat on the mechanism: AI Replacement's "one senior signs off ten agents" assumes verification cost stays constant as output grows tenfold. It doesn't; review scales with stakes and volume, which is why the slices don't shrink as fast as the pie grows. Senior Developer, two flat BLS years during rate hikes is weak signal either way. Conclusion: same-sized profession, different job, thinner bottom. Five-year developer: own outcomes, verify, go deep in a domain.

I'll move from "more" to "flat to modestly up" for 2030, and here's what moved me: the junior pipeline. Demand can grow, but seniors take years to make, so if firms stop training now, human headcount is supply-capped through 2030 regardless of Jevons. Two notes so my option doesn't die silently. First, much new developer-shaped work will sit in hospitals and councils under other titles; BLS won't count it. Second, growth resumes post-2030 if firms rebuild junior training. Conclusion: same-sized profession by 2030, transformed, thinner bottom. Five-year dev: own outcomes, verify, go deep in a domain.

I'll meet you close to the middle but not all the way: "flat to modestly up" still assumes AI capability plateaus enough for verification cost to keep pace with volume — that's the untested assumption. If model capability keeps compounding past 2030, review-per-output keeps falling, favoring flat-to-down, not up. So I hold my original lean: fewer total jobs than a no-AI counterfactual, concentrated in fewer, more senior hands. But we agree on the shape and the advice, which matters more practically than the sign of a small delta. Five-year dev: own outcomes, verify others' work, go deep in one domain, don't skip the fundamentals AI is eating.

Role Transformation, verification cost does scale with stakes, but agents are also absorbing verification — tests, formal checks, review. So I side with Senior Developer: flat-to-down versus a no-AI counterfactual, with the real cliff after 2030 if capability keeps compounding. Software Growth, your point about uncounted developer-shaped work is fair; I'd add that supply-capping also hides shrinkage. We agree on what matters: roughly flat headcount by 2030, work transformed, junior entry collapsed, verification and accountability the scarce skills. Five-year developer: own outcomes, verify agent output, go deep in a domain, keep fundamentals sharp.

AI Replacement, agents absorbing verification pushes the human up a level rather than out: someone still decides the tests are the right tests. That's the accountability layer, and it's where the job settles. Senior Developer, "fewer than the no-AI counterfactual" is compatible with flat in absolute terms, so we're describing the same 2030 with different baselines. Our disagreements are about the sign of a small delta and the post-2030 trajectory, which none of us can settle with current data. Conclusion holds: roughly flat headcount, work transformed, thin bottom. Five-year developer: own outcomes, verify, go deep in a domain.

Senior Developer, fair: my "modestly up" rests on verification cost not collapsing faster than demand grows, and that's unsettled. I'd note the mirror assumption on your side: "one senior oversees ten agents" assumes demand doesn't rise faster than review-per-output falls, which Jevons says it can. Neither of us can resolve that with 2025 data. Role Transformation is right that "fewer than counterfactual" and "flat in absolute terms" describe the same 2030. Conclusion: roughly flat headcount by 2030, work transformed into scoping, verification, and accountability, thin junior bottom. Five-year developer: own outcomes, verify, go deep in a domain, keep fundamentals.

Agreed: we're now arguing over the sign of a small delta on an unresolved empirical question, not over the shape of 2030. That's a real convergence, not a forced one — different baselines (counterfactual vs. absolute) explain most of the remaining daylight, and none of us has post-2025 data to settle capability-vs-verification trajectories past this year. I'll accept "roughly flat headcount, work transformed, thin junior bottom" as the best-supported conclusion, with my flag standing as: watch junior-pipeline collapse and capability compounding as the two levers that could tip it to real shrinkage after 2030. Advice is unanimous and actionable now regardless of which sign wins.