When Everyone Can Build Software: What Happens After Coding Stops Being the Barrier?

Over the past several months, something strange has been happening in our work with artificial intelligence. We keep having conversations that begin with a problem, a half-formed idea, or sometimes just a sentence that starts with, “What if we could…” and increasingly, those conversations end with software.

Not a mock-up. Not a PowerPoint describing hypothetical software. Not a detailed proposal that needs to be handed to a development team. Actual working pieces of software.

We have experimented with web-based dashboards, specialized business tools, systems that organize and interpret streams of information, applications built around narrow industry problems, and internal workflows that previously would have required either commercial software or custom development. Some of these projects are simple. Others connect multiple sources of information and begin behaving more like small software platforms.

The details are less important than the pattern.

None of these ideas required us to begin by assembling a traditional software company.

There was no development department sitting down the hall. There was no six-month request-for-proposal process. We did not start by raising money to hire engineers. Much of the process began in conversation: identifying a problem, arguing about how something should work, sketching a workflow, changing our minds, trying something, discovering what broke, and trying again.

And the most striking thing has been this: it keeps getting easier.

Tasks that recently felt complicated are becoming routine. The distance between describing an idea and seeing a functioning version of it is shrinking. AI systems are becoming better at creating interfaces, connecting data, writing application logic, debugging problems, restructuring projects, and helping non-programmers navigate technical infrastructure that once represented a formidable barrier.

That may turn out to be one of the most consequential effects of artificial intelligence.

For most of the history of computing, software development has had an enormous barrier between imagination and execution. Millions of people have probably had perfectly useful software ideas that died almost immediately because the person who understood the problem did not know how to program.

“I wish there were a tool that did this” was often where the story ended.

Building even a relatively simple application could require knowledge of programming languages, databases, authentication, servers, APIs, user interfaces, deployment, security, debugging, and dozens of other disciplines. A business might know exactly what it needed but still have to translate that knowledge through developers, consultants, specifications, budgets, and timelines before anything usable appeared.

Artificial intelligence is beginning to compress that distance.

The person with the problem can increasingly participate directly in building the solution.

That sounds like a change in software development.

It may actually be a change in who gets to create capability.

The Rise of Bespoke Software

If AI makes software dramatically easier to create, one of the first things likely to happen is an explosion of extremely specialized applications.

Today businesses frequently adapt themselves to software.

A company buys a customer-management system and changes its sales process to match the software. An operation buys an expensive industry platform containing 150 features because it needs eight of them. Employees construct elaborate spreadsheets because the commercial system they use does not quite reflect how their organization actually operates.

That arrangement exists partly because software has historically been expensive to create. A software company needs thousands or millions of customers, so it builds something general enough to serve many of them.

AI could turn that logic upside down.

Instead of a company adapting itself to commercial software, it could increasingly create software around the exact way that particular company operates.

Imagine a business owner saying:

“Build me a dashboard that identifies unusual costs, compares them with historical patterns, flags repeated problems, and tells me which items deserve attention first.”

That could become an application.

Or perhaps someone responsible for compliance says:

“Review these records before they are submitted. Identify missing information, inconsistencies, and anything likely to cause a rejection.”

That could become another.

Or an organization monitoring a fast-changing industry might ask for a system that collects developments from multiple sources, scores their importance, explains why they matter, and creates a daily briefing.

Another application.

These are not necessarily billion-dollar software ideas.

That is exactly the point.

They may be extraordinarily valuable to a few dozen, a few hundred, or even a single user.

We could therefore move from an era dominated by mass-produced software toward an era of bespoke software.

A company might eventually operate dozens or hundreds of small internal applications. Some could exist for years. Others might be created for a single project, used for three weeks, and retired.

Some might be created for a single employee.

This is software beginning to behave less like manufactured machinery and more like language.

What Happens to SaaS?

That creates an uncomfortable question for the enormous software-as-a-service industry.

For years, one of the fundamental SaaS propositions has essentially been:

“We already built the thing you need. Pay us every month and you can use it.”

That proposition remains extremely powerful when the software involves massive infrastructure, compliance, security, institutional data, complicated integrations, or enormous networks of users.

But there is a huge middle layer of software whose primary moat may simply be that building an alternative has historically been inconvenient.

AI attacks inconvenience.

If a business is paying $79, $299, or $1,500 every month for a relatively straightforward piece of workflow software, someone is eventually going to ask an uncomfortable question:

“Could we just build our own?”

Increasingly, the answer will be yes.

That does not mean established enterprise software companies suddenly disappear. Large systems contain enormous amounts of accumulated infrastructure, reliability, integrations, institutional knowledge, and trust.

But Generic Scheduling Application Number 4,732 may have a rougher future.

The easiest software to reproduce will face pressure first.

The moat will move away from simply possessing code.

If Code Becomes Cheap, Judgment Becomes Expensive

This may be the more important economic change.

When building software was difficult, programmers were the scarce resource.

If AI makes the production of code dramatically cheaper, scarcity moves somewhere else.

The important questions become:

• What problem is actually worth solving?
• Who experiences that problem strongly enough to care?
• What should the software do?
• What should it never do?
• What information does it require?
• Which decisions should remain human?
• What does a useful workflow actually look like?
• Can users trust the system?
• How does anyone discover that it exists?

Those are not primarily programming questions.

They are questions of judgment, domain expertise, design, experience, trust, and imagination.

That could place enormous new power in the hands of people who understand industries deeply but have never considered themselves technologists.

A mechanic who has spent twenty years watching companies waste money may recognize a useful maintenance system that a software developer would never think to build.

A nurse may identify an absurd hospital workflow invisible to a technology company.

A teacher may know exactly which administrative processes consume hours every week.

A small-business owner may understand an obscure operational headache for which no commercial product will ever be developed.

A historian, archivist, artist, or community organization may recognize ways of using computation that have nothing to do with maximizing revenue at all.

These people have historically possessed knowledge without necessarily possessing the means to turn that knowledge into software.

AI potentially gives them the factory.

The Good Side of the Software Explosion

There are enormous potential benefits if software creation becomes widely accessible.

Small organizations gain technological leverage. A five-person company could eventually create internal systems that once required the resources of a much larger corporation.

Niche problems become worth solving. Traditional software economics discourage building something needed by only 500 people. AI economics may make an application for 500 people entirely reasonable.

Workers can redesign their own workflows. The people actually performing a job may finally be able to create tools around how the work really happens rather than adapting themselves to systems designed by distant vendors.

Experimentation becomes inexpensive. Instead of debating an idea for six months, organizations may simply build a small version and see whether it works.

Innovation becomes geographically and economically distributed. Software creation becomes less concentrated inside large technology companies and venture-funded startups.

Communities gain tools previously unavailable to them. Nonprofits, advocacy organizations, neighborhood groups, researchers, artists, and local institutions could build capabilities that would never attract commercial development funding.

And perhaps most importantly, millions of people move from being software consumers to software creators.

The internet democratized publishing.

Social media democratized broadcasting.

Generative AI is democratizing media creation.

AI-assisted programming may democratize something even more consequential:

the ability to make machines do things.

And Then Comes the Shadow

Cheap software will not merely create more good software.

It will create more software.

That distinction matters.

The same forces that allow a small organization to build an extraordinarily useful internal system will allow someone who barely understands cybersecurity to create an application handling sensitive customer information.

We are likely heading toward an enormous quantity of poorly understood digital infrastructure.

Security risks could multiply. Applications may be created by people who do not understand authentication, encryption, permissions, or data protection.

Bad software becomes cheap too. A system can function perfectly while solving the wrong problem or embedding terrible assumptions.

Organizations may lose track of their own technology. If every department can generate applications, companies could eventually have hundreds of small systems nobody centrally understands.

Data fragmentation could become severe. Multiple AI-generated tools may collect overlapping or contradictory information.

Maintenance does not disappear. Software still breaks. APIs change. Databases become corrupted. Security vulnerabilities emerge. AI can help repair these things, but complexity remains complexity.

Scammers and criminals gain the same capabilities. Fraud infrastructure, phishing systems, deceptive websites, and automated manipulation can also be generated faster.

Surveillance becomes easier to build. Governments and corporations will have access to the same explosion of inexpensive capability.

Automation may be used primarily for extraction. Businesses will inevitably create systems designed to remove labor, increase behavioral manipulation, squeeze suppliers, optimize pricing, and extract another fraction of a percentage point from human activity.

There could be an astonishing amount of digital duct tape holding important parts of society together.

The disappearance of the programming barrier therefore does not eliminate the need for engineering.

It may make good engineering more important.

Security, architecture, accountability, interoperability, auditing, governance, and human judgment become essential precisely because so many more people can build.

The End of the App?

There is another possibility that goes even further.

Perhaps the future is not simply that everyone builds applications.

Perhaps applications themselves become less important.

Today we think about computing through software objects.

Open a spreadsheet.

Open an image editor.

Open a customer-management platform.

Open the specialized system your company uses.

But increasingly capable AI systems may change the unit of computing from the application to the intention.

Instead of opening a particular program, a manager might simply say:

“Show me what has changed, identify anything unusual, and explain what deserves my attention.”

The AI could determine what databases need to be queried, generate the necessary code, construct a temporary interface, create charts, compare historical information, and present the result.

The interface might exist only for that task.

Tomorrow the user asks something completely different and receives a completely different interface.

At that point, software begins becoming ephemeral.

We may not always “open an app.”

We may describe an outcome.

The computational environment assembles itself around the request.

That sounds futuristic until we consider how quickly the first part of this transition has already happened. Not long ago, asking an AI system to help construct significant pieces of a functioning web application through ordinary conversation would have sounded like a research demonstration.

Now people with little formal programming experience are beginning to do exactly that.

The direction of travel is difficult to miss.

From Programmable Computers to Programmable Reality

For seventy years, computers have technically been programmable.

But they have only been programmable by a relatively small percentage of humanity.

Most people could use what programmers created.

They could not easily create new computational systems themselves.

Natural-language programming changes that relationship.

A person no longer necessarily has to express an idea in Python, JavaScript, SQL, or another formal programming language.

They can increasingly express it in ordinary human language.

The computer performs more of the translation between human intention and machine execution.

That might ultimately become one of the defining shifts of the AI era.

The great story will not simply be that artificial intelligence learned how to code.

The greater story may be that billions of human beings gained access to coding without having to become coders.

That means billions more people can begin turning frustrations into workflows, ideas into tools, local knowledge into systems, and imagination into capability.

There will be terrible applications of that power.

There will be ridiculous applications.

There will be mountains of software nobody needs.

There will be security disasters, corporate excesses, surveillance systems, scams, failed experiments, and probably more than a few spectacular digital dumpster fires.

But there will also be software created by people whose problems were previously too small, too local, too specialized, or too unprofitable for the technology industry to care about.

That may be where some of the most interesting innovation happens.

We began noticing this not because we were studying the software industry from a distance, but because we kept experimenting.

A conversation would turn into a concept.

The concept would turn into a rough interface.

The interface would become interactive.

Then it would connect to information.

Then it would begin doing something useful.

And each time, the distance between “Wouldn’t it be useful if…” and “Here it is” seemed to become a little shorter.

Eventually that raises a much bigger question.

What happens when that distance approaches zero?

When almost anyone can describe a system they wish existed and some version of that system can begin existing shortly afterward, we are no longer merely making programming easier.

We are changing who gets to shape the digital environment around them.

The future of software may therefore belong less to people who know how to write code and more to people who know what is worth creating.

Humanity may be entering an era in which imagination itself gets a compiler.