opendata
Open menu

AI Is Hollowing Out Software From the Bottom

11 min read

The software industry is the first major industry being automated by the product it sells. That is not a slogan. It is now a labor market fact. The people writing code are being displaced, compressed, or re-ranked by systems that also write code.

That is why software looks different from most AI stories. In retail, logistics, or HR, AI arrives from outside. In software, AI arrives from inside the production function itself. The same industry that sells automation is now applying it to its own apprenticeship ladder, support operations, testing workflows, and large parts of routine engineering.

In the underlying industry assessment dated March 25, 2026, the weighted average AI replacement rate across 91 software and internet roles was estimated at 47.3%, and the labor-weighted replacement rate was closer to 55%. That is not full automation. It is something more disruptive: a large-scale compression of the work that used to train the next generation of engineers.

The Market Is Expanding Even as Parts of the Job Base Contract

The first mistake is to assume that a threatened labor market must also be a weak market. Software is the opposite. The market keeps getting bigger while parts of the workforce get squeezed.

The global software market is estimated at roughly $921 billion in 2026, on a path toward $2.47 trillion by 2035, with an expected CAGR of 11.6%. The global SaaS market was about $315.6 billion in 2025. Enterprise AI software spending alone is estimated at $157 billion in 2026, while total global AI spending is projected around $301 billion. The four hyperscalers are expected to spend more than $470 billion in capex in 2026.

That is the important context. This industry is not shrinking. It is reallocating value. Capital is pouring into model providers, AI tooling, cloud infrastructure, and workflow compression rather than into broad-based junior hiring.

The labor side reflects that shift. The source assessment cites a global professional developer population of roughly 28.7 million by one estimate and 36.5 million by another, with a wider total of 47.2 million when hobbyists are included. Yet hiring is weakening where the work is easiest to standardize. In the first two months of 2026, new software engineering job postings were down 15% year over year. 54% of engineering leaders planned to reduce junior developer hiring. Employment rates for developers aged 22-25 were down nearly 20% from their 2022 peak.

The market is healthy. The ladder is not.

AI Adoption in Software Is No Longer an Experiment

By 2026, the adoption numbers stopped looking like early adoption and started looking like operating reality.

The source document cites:

  • 88% of technology companies already deploying AI in at least one business function.
  • 95% of professional developers using AI coding tools at least weekly.
  • 75% relying on AI for at least half of their engineering work.
  • GitHub Copilot reaching 90% of the Fortune 100, with 4.7 million paid users by January 2026.
  • Cursor crossing $2 billion ARR in March 2026.
  • Developers completing tasks 55% faster with AI assistance, with AI generating about 46% of code on average.

That is not a productivity sidecar. That is a workflow rewrite.

The key shift is that AI coding moved from autocomplete to orchestration. By early 2026, the major tools were converging on multi-agent workflows, autonomous code modification, broader repo understanding, test generation, and structured task execution. Once AI can read the codebase, propose the patch, generate the tests, and explain the diff, the pressure lands hardest on work that used to justify junior staffing.

The First Jobs to Break Are the Ones Built on Repetition

The software industry likes to imagine AI as a threat to abstract engineering genius. In practice, the highest-pressure roles are much more ordinary. They are the roles built around repetitive ticket handling, template generation, regression testing, reporting, and standardized implementation.

The Most Exposed Roles

Role Estimated AI replacement rate Why it is exposed
L1 Technical Support Engineer 90% High-volume, repeatable support flows are now ideal for AI routing and resolution
Report Developer 75% Natural-language BI tools now generate many standard reports directly
API Developer 75% Standard REST and GraphQL patterns are increasingly machine-generated
QA / Test Engineer 75% Regression suites, test generation, and self-healing automation have matured quickly
System Administrator 75% Standard configuration and management tasks are increasingly codified and automated

The sharpest example is L1 support. The source assessment cites AI chatbot interactions at roughly $0.50 per interaction versus $6.00 for human handling, a 12x difference. It also cites estimates that 75% of customer inquiries can be resolved without human intervention and that AI may handle 95% of all customer interactions by 2026. That is not an efficiency tweak. That is the business case for removing an entire layer of labor.

The same pattern appears elsewhere:

  • Power BI Copilot and Tableau AI turn report generation into a natural-language task.
  • AI testing platforms generate, heal, and maintain large parts of routine test coverage.
  • Cursor, Copilot, Claude Code, and similar tools handle broad categories of CRUD, endpoint creation, and boilerplate implementation.
  • StackGen, Terraform AI, and adjacent tools automate large parts of standard infrastructure definition.

This is not because AI is “smarter” than the best engineers. It is because these jobs were already partially formalized. Once the workflow is predictable, the economics flip fast.

Frontend and Backend Work Are Not Disappearing Equally

A second mistake is to talk about “software engineers” as one labor category. The assessment does not support that. It shows a split between standardized production work and high-ambiguity systems work.

Frontend engineering is highly exposed because modern tools can already turn text into UI scaffolds, component trees, Tailwind structures, and page flows. The source assessment assigns roughly 70% replacement exposure to frontend engineers and 65% to web full-stack engineers. The reason is not that the whole role disappears. The reason is that standard implementation time collapses.

Backend engineering is also exposed, but with a sharper divide. Standard API work, CRUD services, and framework-bound implementation are heavily compressible. The assessment gives 75% replacement exposure to API developers and 65% to backend engineers overall. But once the work turns into distributed consistency, fault tolerance, complex domain rules, high-concurrency design, or ambiguous tradeoffs, the replacement rate drops materially.

This is the core pattern across the industry: the more the work looks like templates, the more it moves toward software. The more it looks like judgment under constraints, the more it remains human.

The Middle Layer Is Being Compressed, Not Deleted

Software layoffs are often framed as a simple substitution story. The deeper change is middle-layer compression.

Many roles are landing in the 30-60% replacement band rather than at either extreme: platform engineers, data scientists, MLOps engineers, SREs, security engineers, product managers, LLM engineers, cloud architects, and many forms of systems integration.

These jobs are not fully automatable because they combine structured outputs with messy environments. AI can generate the query, scaffold the pipeline, write the config, summarize the incident, draft the PRD, and propose the architecture. But it still struggles with tradeoffs that depend on politics, incentives, legacy constraints, timing, reliability, or business context.

That is why so many roles in the study settle into partial replacement rather than near-total elimination. The human is still needed, but the team needs fewer of them to ship the same volume of work.

In other words, software is not entering a no-engineer future. It is entering a higher-output-per-engineer future. Those are not the same thing if you are on the payroll side of the equation.

The Real Scarcity Is Moving Up the Stack

As routine execution gets cheaper, scarcity shifts toward roles that define systems rather than merely operate inside them.

The Least Replaceable Roles

Role Estimated AI replacement rate Why it remains difficult to automate
CEO 10% Vision, power, investor trust, and stakeholder management remain deeply social
AI Safety Researcher 15% AI cannot reliably self-audit its own safety boundaries
CTO / VP Engineering 15% Technical strategy, organizational design, and talent decisions require leadership judgment
AI Ethics Officer 15% Ethical standards are social and political choices, not just metrics
AI Research Scientist 20% Original breakthroughs still depend on human creativity and theory formation

This is why the software industry is splitting into two labor markets at once. One side is oversupplied: junior developers, L1 support, basic QA, commodity implementation, repetitive internal tools. The other side is undersupplied: AI safety, agent architecture, high-level system design, technical strategy, reliable AI infrastructure, and roles that sit at the boundary between business stakes and technical uncertainty.

The document calls this a “binary labor market.” That is correct, but incomplete. It is really a barbell. The cheap middle gets thinner. The high-leverage edge gets more valuable.

The Self-Replacement Paradox Is Real

Software is the only major industry now living inside a self-replacement loop.

The better the coding models become, the faster engineering teams can ship. The faster they ship, the more capital shifts toward the AI layer and away from routine labor. The stronger that AI layer becomes, the less junior labor is needed to sustain output. That, in turn, raises the economic return on investing even more into AI tooling.

This is why the “vibe coding” moment matters more than it first appeared. Once non-engineers can describe a workflow in natural language and get a working prototype, the market boundary around “who gets to build software” changes. The underlying study points to 2025 and 2026 as the turning point, with vibe coding becoming mainstream enough to be treated as a serious technological shift rather than a novelty.

That does not mean professional engineers vanish. It means the monopoly of professional engineers over first-pass software creation is breaking.

The Biggest Long-Term Risk Is the Training Pipeline

The most underappreciated problem in the whole assessment is not layoffs. It is pipeline failure.

If companies cut junior roles because AI handles the low-level work, they also cut the historical path through which engineers became mid-level and senior. That may look rational in a single quarter. It may become disastrous across a five-year horizon.

The source assessment points to exactly this tension: companies are reducing early-career hiring while still needing senior judgment, architecture, security, and AI systems expertise. That creates a structural contradiction. You cannot continuously harvest senior talent if you stop funding the ecosystem that produces it.

The software industry has spent years assuming that skill formation would take care of itself. AI makes that assumption dangerous. If entry-level engineering becomes too thin, tomorrow’s staff engineers, platform leads, and technical directors do not materialize on schedule.

The Safe Work Is Not “Coding.” It Is Ambiguity

The safest work in software is no longer defined by programming language or domain label. It is defined by how much ambiguity, judgment, coordination, and irreversibility the work contains.

Work becomes harder to automate when it requires:

  • designing under uncertain requirements,
  • balancing conflicting business goals,
  • choosing between multiple valid architectures,
  • reasoning about failure in novel conditions,
  • persuading humans across teams,
  • or setting standards for what the system should do in the first place.

That is why architecture leadership, AI safety, research, governance, and high-level product strategy remain relatively protected. These are not the most technical jobs in the narrow sense. They are the jobs where the technical answer depends on a human choice.

By contrast, work becomes easier to automate when it is:

  • repetitive,
  • benchmarkable,
  • framework-bound,
  • low-ambiguity,
  • and easy to evaluate after the fact.

That is why support, reporting, standard testing, standard APIs, and internal tools are moving so quickly.

What Companies Should Actually Do

The wrong response is to ask whether AI can replace software teams. The better question is which layers of software work should become software themselves.

The underlying study implies a practical three-part map.

  1. Automate aggressively
    L1 support, regression testing, standard reporting, boilerplate APIs, routine infrastructure configuration, and simple internal tools.
  2. Compress with human review
    Backend implementation, frontend implementation, QA strategy, DevOps operations, analytics, BI, project coordination, and many forms of enterprise integration.
  3. Protect and invest
    AI safety, security strategy, architecture, platform governance, senior product judgment, research, and leadership roles that combine technical depth with organizational influence.

The firms that win will not be the ones that merely cut headcount fastest. They will be the ones that redesign workflows without destroying the skill pipeline they still need.

What Software Professionals Should Do

The old hedge was to learn to code. The new hedge is to become expensive where code alone is not enough.

That means moving toward:

  • system design over isolated implementation,
  • reliability over raw speed,
  • problem framing over task execution,
  • architecture over boilerplate,
  • evaluation over generation,
  • and human coordination over solo output.

The engineers at highest risk are not the weakest engineers. They are the engineers trapped in the most repeatable parts of the workflow. The engineers with the strongest position are the ones who can supervise, constrain, and redirect automated systems toward business reality.

The Structural Conclusion

Software is not dying. It is becoming more productive, more unequal, and less forgiving.

That is the real meaning of AI in this industry. The market keeps growing. Capital keeps rising. Infrastructure investment accelerates. Tool vendors explode. But the distribution of human value inside the industry changes. Entry-level roles get thinner. Middle layers get compressed. High-ambiguity roles gain strategic weight.

The software industry is not the exception to the AI labor story. It is the leading indicator. It shows what happens when automation reaches an industry whose main output is already abstraction. The first thing to disappear is not creativity. It is routine execution. The next thing at risk is the ladder that used to turn routine execution into expertise.

If you are building software products that depend on public records, company intelligence, or structured data workflows, opendata.best and the API docs can reduce the time spent on fragmented data collection and repetitive integration work.

Sources

All market sizing, labor market figures, role exposure estimates, and product examples in this draft were adapted from the underlying software and internet industry assessment and its cited references.

Ready to try the data?

Start exploring public data APIs with a free search

Start with a free search
Back to blog