Twenty-five years ago, I was debugging C++ in a windowless office, surrounded by O’Reilly books with animals on the covers. The notion that someone without formal training could build production software felt absurd. Programming required years of study and intimate knowledge of memory management. Compiler errors read like accusations.

That world is gone.

According to SlashData’s latest research, there are now 47.2 million developers worldwide. That’s a 50% increase from just three years ago. But the composition of that growth tells a more interesting story: professional developers grew by 70% while amateur developers actually declined by over a million in the past year.

We’re not just seeing more people code. We’re seeing programming become a stable career path while the hobbyist tinkerer fades.

The Professionalization Shift

The decline of amateur developers surprised me as I was digging into the topic. Back when I started, the path often went: hobbyist → self-taught professional → formal training (maybe). People messed around with QBASIC, PASCAL, or FORTRAN on weekends, and some of those experiments turned into careers.

That pipeline seems to be drying up. More people are attending university or bootcamps with the explicit goal of becoming software developers from day one. They’re building careers, not exploring interests. The romantic image of the garage programmer discovering a passion has been replaced by the pragmatic reality of a well-paying profession that requires intention.

Meanwhile, Gartner projected that 70% of new applications will use low-code or no-code technologies by 2025, up from less than 25% in 2020. Based on what I’m seeing on LinkedIn, StackOverflow, and other outlets, that estimate tracks. By some estimates, large enterprises already have four times more citizen developers than professional ones. We’re seeing that day-to-day as more of my peers embrace low-code tools like PowerApps, CoPilot Studio, and others to build applications for their teams.

From Machine Code to Natural Language

The evolution follows a pattern that now seems inevitable in hindsight. Machine code gave way to assembly, then high-level languages, then object-oriented programming. Each step abstracted away complexity and expanded who could participate.

We’ve now crossed into something different. A 2025 study in the Journal of Computer Science and Technology Studies’s original framing of “vibe coding” continutes to build a bridge betweennatural language and functional software. Y Combinator reports that 25% of their Winter 2025 batch had codebases that were 95% AI-generated.

Tasks that once required a dedicated developer can now be handled by a product manager with the right prompts. The skill shifted from writing code to describing intent clearly. Communication, it turns out, remains the core skill it always was.

What Actually Changed

While the numbers tell a story of democratization, they miss something important about how teams operate now. Manufacturing has doubled its developer population in three years. Data analytics grew from 4 million to 5.8 million developers in the same period. Software isn’t eating the world anymore; it’s becoming the baseline assumption.

The organizations I work with now have a different problem than they did a decade ago. Then, the challenge was finding enough developers. Now, it’s coordinating the development happening across the entire organization, often without a centralized “engineering team” having knowledge or approval. Is that a problem? I don’t know.

Low-code platforms deliver 50-70% faster development cycles. That’s real. But faster development of what? The governance questions that used to apply only to engineering teams now apply to marketing, finance, and operations. Shadow IT evolved from “someone running an Access database” to “someone deployed a production workflow to 500,000 users.”

I’m not sure we’ve figured out how to manage this yet. The tooling got ahead of the organizational structures.

Still Figuring It Out

The romantic in me misses something about those early days. There was a craftsmanship to understanding how memory worked and why certain patterns mattered. That knowledge isn’t worthless now, but it’s becoming specialized rather than foundational.

The pragmatist in me sees 47.2 million people building software and thinks: this is probably good. More people creating solutions to their own problems. More domain experts building tools for their domains. The alternative was gatekeeping that served no one particularly well.

What I’m less certain about is quality. The citizen development movement celebrates velocity, and rightfully so. But the bugs in no-code workflows are familiar ones. Unclear requirements lead to missing edge cases, and integration failures only appear at scale. We just encounter them faster now.

The question isn’t whether everyone can be a developer. They already are. The question is whether we’ve built the support structures for 47 million people to develop well.

I suspect we’ll spend the next decade finding out.