Beyond 2030: When Everyone Can Build

The first two parts of this series traced the rise of new builders, and the entrance of AI as a creative partner.

But, the most important shift is still ahead.

Over the next decade, as hundreds of millions of people gain the ability to create software, the distance between problems and solutions will shrink. Ideas won’t have to survive the long route through managers, technical backlogs, prioritization queues, or funding cycles. The person who spots a gap will be the one creating its solution.

In that world, building software will feel as ordinary as structuring a spreadsheet, composing a document, or designing a slide deck. It’ll become part of everyday work across fields, industries, and skill levels.

When someone can describe an idea in plain language and watch it take shape as a functioning system, software stops being a product delivered by specialists. It becomes a shared medium for reasoning, coordination and problem solving.

Below, we’ll examine how this shift could unfold. How it’ll change the role of professional developers, how organizations will need to adapt, and why tools like Memex are emerging to meet this moment.

The Scale Ahead

Based on industry reports, the population of software creators has three main trajectories. The exact numbers differ based on adoption speed, governance environments, cultural readiness, and how quickly tools mature. But across every projection toward 2030, the direction is consistent: more people gain the ability to build, and the center of software creation frontier shifts outward.

Table: Projected number of people globally building software in 2030 (in millions). All figures are estimates based on trend extrapolations. The base case reflects the midpoint of industry forecasts. Conservative assumes slower adoption of no-code and AI; aggressive assumes faster and broader adoption.

The numbers illustrate three important insights:

1. In every scenario, professional developers become a minority of total builders.

2. AI-assisted creation becomes the standard workflow for those developers.

3. The majority of new builders come from outside formal engineering roles.

The operations manager designing an automation, the researcher modeling data for a specific inquiry, and the founder assembling a proof-of-concept product are not peripheral cases. They are the new normal.

When Building Becomes Ordinary

As software creation becomes more accessible through natural language, the capacity to build no longer sits with a small group of specialists. The result isn’t just more creators and products; it’s a different relationship between problems and solutions.

Here’s what we expect to see on the road to 2030 and beyond: 

1. Solutions Move Closer to Practitioners

At most companies today, the person with an insight isn’t usually the one who builds and implements the solution.

Let’s say a frontline professional identifies a problem. Their manager translates it into project language, and a product team scopes it. Then, an engineering team tries to prioritize this task among dozens of other requests. Unfortunately, it’s common for ideas to get jammed up in the system’s machinery, or even dissolve entirely.  

In the decade ahead, that translation chain shortens dramatically. For instance:

• A warehouse scheduler can adjust routing logic based on actual constraints of loading docks and staffing.

• A small business owner can build a customer intake system that reflects how their clients communicate and schedule.

• A research lab manager can assemble a data logging interface that matches the instruments, timing, and workflows of their experiments.

• A nurse can create a follow-up system aligned with patient discharge patterns.

• A clinic administrator can create a care coordination dashboard that accounts for appointment timing, provider availability, and follow-up requirements.

• A product manager can create a dashboard of product usage data.

These are not general-purpose apps; they’re built with a level of insight that only practitioners have. The closer software sits to the relevant context, the more effective it becomes.

2. Hyper-Specific Software Becomes Economically Viable

For a product to justify its cost, it needs a broad enough market to sustain ongoing development and support. As a result, countless needs remain unaddressed simply because they are too small to produce a business case.

When millions of people can build, scale is no longer the limiting factor. By 2030, we’ll see software designed for:

• A single surgical department that needs to coordinate post-op follow-ups hour by hour.

• A specific logistics corridor between two distribution hubs with unique timing and capacity constraints.

• A neighborhood food pantry coordinating pickups based on local transit and volunteer schedules.

• A family-run farm managing irrigation cycles tied to its own soil, crops, and weather patterns.

• A small bakery handling custom holiday orders with timing that depends on proofing, cooling, and staffing.

• A mortgage brokerage manager can build a CRM tailor-made to their needs.

These tools don’t need to scale to be successful (even though they can!); they only need to solve specific problems. Their success will be measured by how accurate and useful they are, not broader adoption or distribution.

3. Software Literacy Becomes a Core Skill

This prediction isn’t about turning everyone into an engineer. It’s about enabling people to express logic clearly, evaluate outcomes thoughtfully, and iterate based on what they observe.

By 2030, the practical skills that matter most will include:

• Breaking a workflow into clear steps.

• Identifying where data enters, moves, and changes state.

• Communicating intent precisely to an AI collaborator.

• Evaluating whether a system produces the desired result.

• Refining tools based on real-world use.

This resembles how spreadsheet literacy spread in the 1990s. Most spreadsheet users weren’t mathematicians, but they could express relationships, constraints, and decisions effectively. Excel didn’t become popular because people learned advanced math, but because its interface aligned with how we already reason.

Software creation will follow this same trajectory. People won’t need to understand compilers, frameworks, or architectural patterns. The more clearly someone can describe a process and its logic, the more effectively they’ll be able to work with AI-powered systems, build tools and solve problems.

The Changing Role of Professional Developers

Professional developers will always be essential, and the nature of their work will continue to shift upward. By the end of this decade, they’ll have an even stronger focus on:

• Designing the shared systems that ensure stability, security, and reliability.

• Creating frameworks, templates, and components that others can build with.

• Integrating advanced systems and maintaining complex infrastructure.

• Mentoring new builders and reviewing critical workflows.

• Safeguarding systems where failure carries real-world risk.

In effect, they become stewards of the broader software environment, enabling more people to build while ensuring that these new tools can be trusted and maintained. Instead of being the sole creators, they’ve become multipliers, and their leverage increases as the number of builders grows.

The Pressures of Scale

Widespread software creation will introduce new challenges. As a result, companies will need to change how they review, secure, and understand what is created.

Key areas of focus will include: 

• Quality and Reliability. Teams will need consistent review processes, shared architectural patterns, and clear testing standards to ensure that systems remain dependable as they evolve.

• Security and Data Integrity. More builders means more integrations and data flowing between systems. Governance must ensure privacy, compliance, and responsible access at every point of connection.

• Provenance and Transparency. When AI participates in design and implementation, it becomes essential to understand why a system functions the way it does. Organizations will need access to reasoning histories, decision traces, and clear documentation to maintain continuity and trust.

The companies that succeed in this next phase will not be the ones that restrict building, but that guide it with the necessary frameworks. They’ll treat software creation as a shared capability and invest in practices that support clarity, safety, and accountability. When the right foundations are in place, more people can build well, and the systems they create can endure.

Why a New Type of Tool Is Needed

If hundreds of millions of people are going to build software, the tools they use cannot require specialized syntax, rigid templates, or predefined structures. The interface for building must align with how humans actually think, reason and communicate. It should be ergonomic and flexible.

This means software creation must move closer to natural expression. Instead of translating ideas into layers of instructions, people should be able to describe goals, constraints, and relationships directly. Then, have the system interpret and implement them.

This requires a tool that can:

• Understand intent expressed in plain language.

• Plan and coordinate entire systems, not just code fragments.

• Work across local and cloud environments with equal fluency.

• Maintain context across sessions, tasks, and platforms.

• Adapt to the person building.

This is the role Memex is designed to fulfill.

In a nutshell, it’s an AI software engineer for humans: collaborating through natural language, planning architectures, writing and refining code, deploying across environments, and continuing to evolve alongside the person building.

Also, it doesn’t limit creation to templates or one-off automations. Memex can preserve continuity of thought across sessions, platforms, and works the way people do. Meaning iteratively, conversationally, and with awareness of purpose.

The Path Forward

By 2030, the number of people who build software will expand to hundreds of millions. In the decades that follow, it may reach billions.

At that point, software will cease to be something separate from everyday work. It’ll be a standard medium for solving problems, coordinating effort, and expressing ideas.

The most meaningful change won’t be the increase in builders; it’ll be the shift in proximity. 

Software will be within reach of the people who understand a problem best, closer to the moment an insight appears, and nearer to the context where decisions are made. Tools will become far more adaptive, and teams will learn to guide AI systems, not just operate them.

Software reshaped the world by expanding what organizations could do. In the years ahead, the world will reshape software by broadening who is able to create it. The impact of this shift will depend on how intentionally we support it, how well we build our systems and frameworks, and how widely we extend the ability to participate.

This is the future we’re heading toward. And, it’s already begun.