Are engineers becoming worthless? Yet the software market is racing toward $58.2 billion: when 180 million people can all build software, AI is turning software creation into the next growth frontier

Are investors planning to stop pouring resources into the software industry? That's actually a huge question mark. Because if we shift our perspective back to the market itself, even though programmer job openings are projected to decline by 7% over the next decade, the population of people making software has surged by 36 million in a single year. So in reality, what AI is pushing down is the price of "writing code," but what it's expanding is the entire software market.

From where I stand, the software market is going through the biggest expansion in its history, and the driving force behind that expansion happens to be the very thing making engineers anxious: AI can now write code. AI has turned the technical language once required for digital environments into ordinary human speech, accelerating the time it takes for two species—humans and digital intelligence—to communicate with each other.

Let me put the conclusion up front. The U.S. Bureau of Labor Statistics projects that the "Computer Programmer" occupation will shrink by 7% over the next decade. But at the same time, GitHub added more than 36 million new developers in a single year, and Gartner forecasts the low-code development technology market will reach $58.2 billion by 2029. Put these three numbers together and they're telling the same story: the barrier to entry for writing code has gotten cheaper and easier, so there's more software, and so there are more people making software. One kind of engineering job will disappear, but the software market will grow several times over.

Since starting my company—actually, even earlier, since I wrote my first line of HTML code back in 1995 as a kid—the world I've known has been an accelerating one. Computers aren't fundamentally different from past carriers of human information; they just happen to be able to do a tremendous number of things. They're like radio, television, even film—all carriers of content—except they can do it faster, reach more people, and carry more functions.

When Aotter was founded in 2013, we got involved in a lot of co-creation communities—what people called the Maker community, which was red-hot nearly 15 years ago—using manufacturing equipment that moved from factories into homes, combined with the spread of smartphones and mobile apps, to build a world where products could be made much faster. The same thing happened in the content creator industry: from needing large-scale, expensive production setups, it gradually shrank down to the point where, in a limited space with a green screen, a phone, and some LED lights, you could achieve results close to what a professional studio used to produce. This is a real embodiment of how technology shortens the distance to value creation. The one place where the digital content industry (or what we might call the "brain" industry) has always seemed to lag behind is that technical talent—software engineers—remained scarce, and the market exhibited that classic "scarcity breeds value" phenomenon. Companies with resources or capital, ignoring actual output per person-month, would treat having more engineers as one of their own indicators of capacity or quality assurance—and that, again and again, is a phenomenon that only shows up in a relatively backward industry. Over these past years of writing code myself, building products, and leading teams, I've watched full-stack frameworks come and go, watched simple front-end languages get wrapped in increasingly over-engineered libraries, and then watched the AI era march forward generation by generation—Copilot, Cursor, Claude Code, Codex, Vibe Coding, Agents. I've become more and more convinced: what's actually shrinking, when you zoom out, is the constraint itself that "only Programmers can create Software."

Below, using five sets of data from authoritative institutions, I'll describe the market shift I'm seeing, and the new role being born within that shift: the Software Creator. I don't even think "Builder" is the right term to describe this role that's been springing up like mushrooms after rain, thanks to vibe coders.

I. Programmers Are Shrinking, Software Developers Are Growing

A lot of people lump "people who write code" together with "people who make software," which is why they end up asking the wrong question.

The U.S. Bureau of Labor Statistics' (BLS) latest 2025–2035 occupational employment projections happen to split these two groups apart:

Computer Programmers are projected to decline by 7%, Software Developers are projected to grow by 10%, and Information Security Analysts are projected to grow by 21%; over the same period, the average growth across all occupations is only 3.5%. The BLS states it plainly on the programmers page: companies will use technologies including AI to automate repetitive programming work, while higher-level work shifts to software developers.

This chart describes a structural shift: "Coding" is getting cheaper, and "Software" is getting more valuable.

As more and more code gets handed off to AI, human value shifts elsewhere. Do you know what problem needs solving? Do you understand how the industry works? Can you turn the requirements of five different departments into a single workflow? Do you know how to model the data? Do you know which decisions can't be left to an Agent? Do you know where things will blow up once they hit production? Go one level deeper: do you understand databases, distributed systems, security, infrastructure?

These capabilities will be worth more than "turning a spec into code."

II. The Definition of "Developer" Is Expanding: 48.4 Million, or 180 Million?

How many developers are there, really? The answer depends on how you count—and the gap between the two ways of counting is exactly what's worth paying attention to in this market.

SlashData estimates 48.4 million developers worldwide as of Q3 2025, up from just over 31 million in early 2022—roughly a 50% increase in a little over three years; among them, professional developers grew from 21.8 million to 36.5 million, a 70% increase. SlashData also notes that the year-over-year growth rate has slowed from 15% and 21% down to 10% in the most recent year, suggesting things may be cooling off.

GitHub's number is on a different order of magnitude entirely. Per the Octoverse 2025 report: the platform now has over 180 million developers, with more than 36 million joining in a single year (a 23% year-over-year increase)—averaging more than one new person per second; nearly 80% of new developers used GitHub Copilot within their first week. Public repos using LLM SDKs now exceed 1.1 million, up 178% year-over-year.

180 million GitHub accounts obviously doesn't equal 180 million professional engineers. Research firms count "people whose profession is development"; GitHub counts "accounts actually building things on the platform." The gap between these two numbers is exactly where the emerging population of Software Creators is growing.

In the past:

Software Creator ≈ Programmer / Engineer

Now it's gradually becoming:

Software Creator
= Engineer + Founder + PM + Designer + Analyst
+ Marketer + Consultant + Operator + Researcher
+ Ordinary users + AI Agents

As far back as late 2022, Gartner predicted: by 2026, developers outside of formal IT departments would account for at least 80% of low-code development tool users, up from 60% in 2021. These people don't have "Software Engineer" on their LinkedIn, but they're making software every single day.

I've deliberately avoided throwing out a number like "how many Software Creators there will be by 2027," because no research institution has done this kind of population forecast yet, and any number I guessed wouldn't be any more credible. But the direction is clear: the professional developer population is still growing but slowing down, while the population of people making software is expanding at a different speed entirely.

III. Software Creator: A New Role Officially Arrives, and Its Momentum Can No Longer Be Ignored

Put the two sets of data above together, and you'll see a new role has already taken shape: the Software Creator. They make software, but their work, their tools, their output, and their responsibilities are all different from the Programmer we're familiar with. This role is becoming the single biggest driving force in the next phase of the software market, and the evidence is already showing up in institutional data: GitHub added 36 million new developers in a single year, with nearly 80% using Copilot in their first week; Gartner projects that by 2026, 80% of low-code tool users will come from outside formal IT departments; the BLS projects that repetitive coding will get automated while higher-level work shifts to software developers. Three institutions, three angles, all looking at the same crowd pouring in.

This is a lot like YouTube's relationship to the video industry. Photographers, editors, and directors as professions still exist, but what really expanded the video market tenfold was the "Creator"—a role that didn't exist before at all. Software is replicating the exact same path.

I've broken down the biggest differences between Software Creators and Programmers into five points:

First, the starting point is different. A Programmer's work begins with a "spec"; a Software Creator's work begins with a "problem." They themselves are the person who understands the business, the person who deals with the problem every single day. A retail operations manager's restocking tool might end up closer to reality than one built by an engineer who doesn't understand retail at all, because the manager knows which column of numbers actually matters.

Second, the core tools are different. A Programmer's core skill is syntax and algorithms; a Software Creator's core skill is "clearly articulating intent" plus "judging whether the Agent got it right." Anthropic's Economic Index found that the share of conversations on Claude.ai where the "entire task is handed off directly to AI" rose from 27% to 39%—which is exactly this new way of working: humans handle intent and review, Agents handle building.

Third, the unit of output is different. A Programmer delivers "features"; a Software Creator delivers "outcomes." For a lead-gen app built by a salesperson, or a check-in tool built by an event PM, there's only ever one metric: did this month's problem get solved? That's why software built by Software Creators can have a very short lifecycle—sometimes living for just a single event or a single campaign.

Fourth, where they're positioned is different. Programmers cluster in IT departments and software companies; Software Creators are scattered across marketing, operations, finance, sales, customer service—every corner where repetitive work exists. That Gartner figure of "80% outside of IT" is exactly describing this.

Fifth, where responsibility lands is different. When code is generated by AI, the responsibility a Software Creator truly has to bear is judgment: can this ship? Was the data pulled correctly? Were permissions set correctly? In the Stack Overflow survey, 46% of developers don't trust the accuracy of AI output—which illustrates exactly where this role's value lies: between "almost right" and "actually right," you need someone who understands the business and can also read the results, to serve as the gatekeeper.

Put these five points together, and that's why I believe the Software Creator will become an independent role—and will become the single biggest driving force in the next phase of the software market: they outnumber professional developers several times over, they're scattered across every industry, and they're building software that would never have been built in the past.

IV. Talent Is Concentrating at Two Extremes, and the Middle Is the Most Dangerous Place to Be

I'd roughly divide the technical talent that will truly hold value in the future into two extremes—and the two look completely different from each other.

The first extreme is people who go very deep: people who genuinely research databases, compilers, operating systems, models, GPUs, security, distributed systems, infrastructure. AI can help them write code, but as the entire world is built on more software, more Agents, more APIs, the people who truly understand the fundamentals become even scarcer. If the number of people at the top increases a hundredfold, the people laying the foundation at the bottom won't increase a hundredfold at the same time. Truly strong infrastructure-level engineers will become fewer, more expensive, and more leveraged.

The other extreme is the opposite: people who understand one domain deeply and can also do a little bit of everything. Someone in advertising who understands media buying, media, sales, CRM, has some data skills, can write a bit of API code, can prompt well, understands some UX. In the past, this person touched everything but couldn't ship a product; now, with AI Agents, they may well be more capable of building "a product an ad agency would actually buy" than a Programmer who codes fast but doesn't understand advertising at all.

That huge middle chunk of work—"write the code according to the spec"—is the piece most easily compressed.

The numbers from Stack Overflow's 2025 Developer Survey explain exactly why "judgment" is becoming more valuable than "generation":

84% of developers are using or planning to use AI tools (up from 76% the previous year), and 51% of professional developers use it daily. But 46% don't trust the accuracy of AI output, with only 33% expressing trust; 66% say their biggest frustration is that AI output is "almost right, but not quite right"; 76% have no plans to hand deployment and monitoring over to AI.

Code generation is rapidly becoming a commodity. The genuinely hard work is shifting toward judgment, verification, architecture, domain knowledge, and accountability.

V. The Software Market Is Shifting From "Enterprise Procurement" to "Everyone Creates": $58.2 Billion Is Just a Number Under an Outdated Category

My judgment is that most people's current estimates of the AI coding market are too small, because they're still calculating it as "number of developers × IDE subscription fee."

Let's start with the data. Gartner's November 2025 forecast: the global low-code development technology market will reach $58.2 billion by 2029, with a projected CAGR of 14.1%; Gartner's forecast in late 2022 for 2023 was $26.9 billion. Looking just at the segment Gartner originally defined as low-code, it's roughly doubled in about six years. More importantly, the growth drivers Gartner names are: Agentic AI and Citizen Development.

Low-code is still a category from the previous generation. Low-code still assumes "a human operating a builder"; AI-native software creation already assumes "a human stating intent, an Agent operating the builder." This is a market of an entirely different order.

Venture capital's take is also worth considering (this is an opinion, not statistical data). In March this year, a16z published a piece titled "Good news: AI Will Eat Application Software," directly pushing back against the pessimistic market view that "AI will kill SaaS": "As code gets cheaper, we should expect demand for more software," and "we are nowhere close to satisfying the world's demand for quality software." By August, they put it even more bluntly: "AI coding may be the largest addressable market we encounter in our lifetimes."

In the past, before turning a need into software, you had to ask "is it worth spending a million dollars on this?" Now it's "is it worth spending an afternoon on this?" That's a completely different economic model.

Let me give a somewhat silly but very illustrative example of this future. Five friends go to Japan, come back to the hotel at night, start drinking, and suddenly realize, "damn, we don't have a board game." Today, we'd go to the App Store, search for a game, download it, register, watch ads, study the rules—and we might not even find one suited for exactly five people. A few years from now, it's entirely plausible that one of them will just tell an Agent: "There are five of us—build us a 30-minute party game with some psychological bluffing, playable together on our phones, join by scanning a QR code." The Agent spends a few minutes building the game state, generating a web UI, opening a room, producing a QR code, deploying it. Two hours later, the game's over, and nobody ever uses it again.

This thing's entire lifecycle is just two hours, but it genuinely created value. In the past, this kind of software didn't make sense because development cost > usage value; in the AI era, we'll start seeing cases where development cost < one-time usage value. Once that equation flips, the sheer number of software products is going to explode.

The concept of "an app" itself will change too. In the past, it was "someone spends months building it → it ships → everyone downloads it"; in the future, we'll see more and more just-in-time applications: I need it, so I build it now, and once I'm done using it, that's that. Some will stick around, some will iterate, some will live for 30 minutes, and some will grow from a tiny tool into an entire SaaS company.

So the real question to ask is: when hundreds of millions of people occasionally create software, what infrastructure will they need? This is a completely different TAM.

VI. The Better AI Gets at Writing Code, the More Valuable the Infrastructure Layer Becomes

Let me state the conclusion first: code generation will be the most fiercely competitive, thinnest-margin layer of this wave; the layer that's genuinely hard—and genuinely huge—is "what happens after it's built."

OpenAI, Anthropic, Google, Cursor, Replit, and Lovable are all working on code generation, and every model will inevitably keep getting better at it. "Generate me a button" going wrong isn't a big deal; "touch the production database" is a completely different matter. Once AI makes the front half of software creation cheap, the back half becomes even more important: data, permissions, identity, business logic, deployment, monitoring, rollback, audit, security, human-in-the-loop. What exactly can an Agent do? And when does it absolutely have to ask a human first?

Four numbers from different institutions all point in the same direction:

First, platforms. Google Cloud's 2025 DORA report puts it plainly: AI doesn't fix a team, it amplifies whatever was already there. 90% of respondents use AI at work, over 80% believe it increases productivity, but 30% have almost no trust in AI-generated code; AI adoption correlates positively with delivery throughput but negatively with delivery stability. DORA's conclusion: 90% of organizations have already adopted at least one internal platform, and platform quality is directly tied to whether an organization can actually capture value from AI. The better AI gets at writing code, the more important the platform layer becomes—these two things aren't contradictory at all.

Second, protocols. MCP's growth rate is genuinely staggering. When the official MCP team released the new spec version in July 2026, they disclosed that first-party SDKs are seeing nearly 500 million downloads per month, with the TypeScript and Python SDKs each having crossed 1 billion downloads cumulatively. What MCP fundamentally solves is simple: letting an Agent know what tools exist, how to call them, which data it can read, and which actions it can execute.

MCP still largely lives in the server/backend world. This year, WebMCP started to fill in the other half: co-drafted by engineers from Google and Microsoft, housed under the W3C Web Machine Learning Community Group, first made public in August 2025, it's still a draft and has not yet become an official standard; Chrome began an Origin Trial for it in Chrome 149 in June 2026. WebMCP lets a website directly tell an Agent "I have searchProduct, addToCart, createBooking, approveExpense," replacing "look at a screenshot, guess which element is a button, move the mouse, click, screenshot again, guess again" with structured tools. WebMCP's own documentation states it clearly: it's designed to complement existing backend protocols (such as MCP), not replace them; a webpage that implements WebMCP can be treated as an "in-page MCP server."

The way I think about it:

MCP     = The API Layer of the Agent era
WebMCP  = The Interactive Web Layer of the Agent era

The role of the web is becoming hugely important again as a result. It's the most ubiquitous, most cross-platform application runtime in the world, with nearly zero installation cost. For that game dreamed up on the spot at the hotel, nobody's going to want to package it as an iOS app and submit it for review—the most natural path is Agent → generate → deploy → URL → QR code → browser, usable within five minutes. As just-in-time software proliferates, the URL will become a critically important application distribution layer once again, and the browser will simultaneously serve as both the human interface and the Agent interface.

Third, delegation. Anthropic's Economic Index is already seeing usage patterns shift: the share of "directive" conversations on Claude.ai—where the entire task is handed directly to AI—rose from 27% in December 2024 to 39% in 2025; 44% of enterprise API usage falls into computer-and-math-related work, an even higher concentration than the 36% seen on Claude.ai. People are gradually shifting from operator to intent-setter, reviewer, decision-maker, and owner.

Put these three signals together and you get a single paradigm shift: in the future, from the very first day a piece of software exists, it should assume that both humans and Agents will use it. Today we design APIs because software needs to talk to software; in the future, from Day 1, a huge share of applications will need to account for both the human UI and the Agent tool interface at the same time.

Why Aotter Keeps Building the Data Layer and the Application Layer

Now, finally, it's Aotter's turn.

This is the underlying logic connecting what might look like a scattered bunch of products we've built recently. What Aotter has always set out to do is actually simple:

Shorten the time it takes to create value.

In the past, we worked on data, because data was scattered across different places, hard to see, and slow to organize—so we tried to shorten the chain from data → insight → decision. With AI, this chain can now extend even further forward:

Idea → Data → Context → Logic → Application → Action → Value

Every segment of this can now start being accelerated by an Agent. So what we're especially focused on right now are the two layers most prone to breaking in the middle:

The Data Layer solves whether AI actually knows what's happening inside a company. The Application Layer solves whether, once AI knows what's happening, it can actually "do things."

If the Software Creator population really does expand from "developers" to "everyone who understands the business," the imagined user of a product has to change too. Instead of asking "would an API engineer understand this?" we now have to ask "can someone who understands retail work alongside an Agent to build out a retail workflow?"; instead of "will the backend team be able to deploy this?" we now have to ask "can this marketing manager turn their own daily repetitive tasks into an application?"—and even "can an Agent itself discover that a tool is missing, and then build that tool?"

So the collaboration tools, data products, and application infrastructure we're building now—including SaaS products like Mantle—are targeting a market bigger than the developer tools market:

Software Creator Infrastructure.

When everyone has the potential to become a Software Creator, what they need is very concrete: a set of infrastructure that lets humans, Agents, data, and applications collaborate reliably—without requiring three years of computer science study first.

This will also rewrite the definition of a "software company." In the future, many companies' core competitiveness will shift from "we have 300 engineers" to "our 30 people can direct 300 Agents, simultaneously operating 200 internal and external software products." At that point, the people who truly matter at a company will be the ones who deeply understand workflows, customers, their industry, data, who are excellent at defining problems, who understand the underlying systems, and who are skilled at judging whether AI actually got it right. Human value is shifting from production toward judgment × domain expertise × architecture × taste × accountability.

My Humble Take, in Summary

In my view, stacking these five sets of data together, I'd sum up my perspective in four statements:

First, engineers will split into two camps, software will explode, and the Software Creator will become an independent role. The pure execution-focused Programmer role will shrink, as the BLS data already shows; infrastructure-level engineers will become scarcer and more expensive; people who deeply understand a vertical and can also direct Agents will become enormously leveraged; people who were never engineers at all will, for the first time, join the software economy. The share of the population doing professional coding will decline, while the population doing software creation will rise dramatically—both of these things will happen at the same time. The difference between Software Creators and Programmers lies in their starting point (problem vs. spec), their tools (intent and judgment vs. syntax), their output (outcomes vs. features), their location (business units vs. IT), and their responsibility (gatekeeping vs. implementation)—and this group will be the single biggest driving force in the next phase.

AI's first-order effect is "engineers write three times as much code in a day"; its second-order effect is "people who never used to make software start making software"; but its third-order effect is the biggest of all: "software that never would have been worth building before now becomes worth building." A workflow used internally at a company for just three days, a management tool used for only two days at a single event, a game friends play together for two hours one night, a lead-gen app a salesperson builds for a single month's campaign, a scheduling Agent a restaurant builds for itself. In the past, none of these had a market, because the cost of development was too high; as the marginal cost of producing software approaches zero, all of them will start to appear.

Third, code generation will become a commodity, and the money will flow toward the infrastructure layer. Data, permissions, deployment, monitoring, protocols, platforms, and "how humans and Agents can safely operate the same piece of software together." The numbers from DORA, MCP, WebMCP, and Anthropic are all describing exactly this.

Fourth, Aotter's position is exactly at this layer. Shortening the distance from data to application, shortening the time from idea to value, and waiting for this Software Creator population to truly explode.

So if someone asks me "will AI shrink the market for software engineers," my answer is: certain engineering jobs, yes. But software itself is standing at the threshold of the biggest market expansion in human history.

Sources

1. U.S. Bureau of Labor Statistics, Occupational Outlook Handbook — Computer Programmers (2025–35 projections): https://www.bls.gov/ooh/computer-and-information-technology/computer-programmers.htm
2. U.S. Bureau of Labor Statistics, Occupational Outlook Handbook — Software Developers, Quality Assurance Analysts, and Testers: https://www.bls.gov/ooh/computer-and-information-technology/software-developers.htm
3. U.S. Bureau of Labor Statistics, Occupational Outlook Handbook — Information Security Analysts: https://www.bls.gov/ooh/computer-and-information-technology/information-security-analysts.htm
4. U.S. Bureau of Labor Statistics, Employment Projections — Occupational projections and worker characteristics (Total, all occupations, 2025–35): https://www.bls.gov/emp/tables/occupational-projections-and-characteristics.htm
5. SlashData, Developer Population (48.4M, Q3 2025): https://www.slashdata.co/developer-population
6. SlashData, Global Developer Population Trends 2025: https://www.slashdata.co/post/global-developer-population-trends-2025-how-many-developers-are-there
7. GitHub, Octoverse 2025 (2025/10/28): https://github.blog/news-insights/octoverse/octoverse-a-new-developer-joins-github-every-second-as-ai-leads-typescript-to-1/
8. Stack Overflow, 2025 Developer Survey — AI: https://survey.stackoverflow.co/2025/ai
9. Gartner, Forecast Analysis: Low-Code Development Technologies, Worldwide (2025/11/4): https://www.gartner.com/en/documents/7146430
10. Gartner press release, Gartner Forecasts Worldwide Low-Code Development Technologies Market to Grow 20% in 2023 (2022/12/13): https://www.gartner.com/en/newsroom/press-releases/2022-12-13-gartner-forecasts-worldwide-low-code-development-technologies-market-to-grow-20-percent-in-2023
11. Google Cloud, Announcing the 2025 DORA Report — State of AI-assisted Software Development: https://cloud.google.com/blog/products/ai-machine-learning/announcing-the-2025-dora-report
12. Model Context Protocol official blog, The 2026-07-28 Specification: https://blog.modelcontextprotocol.io/tags/protocol/
13. Chrome for Developers, WebMCP origin trial (2026/6/9): https://developer.chrome.com/blog/ai-webmcp-origin-trial
14. WebMCP Explainer (webmachinelearning): https://github.com/webmachinelearning/webmcp
15. Anthropic Economic Index, Uneven geographic and enterprise AI adoption (2025/9/15): https://www.anthropic.com/news/economic-index-geography
16. a16z, Good news: AI Will Eat Application Software (2026/3/2): https://a16z.com/good-news-ai-will-eat-application-software/
17. a16z, Cursor + SpaceXAI: the fastest iterating team wins (2026/8/14): https://a16z.com/cursor-spacexai-the-fastest-iterating-team-wins/