The Creator Class
or "School of Rock"
For most of the digital age, building software required learning a language. Not English or Spanish, but more archaic ones like C++, Java, JavaScript, Python. If you wanted to turn an idea into a product, there was an unavoidable translation layer between imagination and reality: code.
That bottleneck shaped the entire technology industry. It determined who could build, who needed permission, and whose ideas saw daylight. The economy was built around the scarcity of programmers.
AI doesn’t eliminate that scarcity by making everyone a programmer. It makes programming less important than deciding what is worth building.
For years we’ve heard the prediction from Marc Andreessen that “software is eating the world” and therefore everyone must become a programmer to partake. That clearly is not what’s happening.
Most people will never want to think about APIs, dependency injection, compiler warnings, or merge conflicts. They shouldn’t have to. Just as film directors don’t operate every camera and architects don’t pour every foundation, future software creators won’t write every line of code, and most won’t ever write even one line of code.
They’ll direct it or perhaps conduct it. The scarce skill shifts from implementation to judgment.
Software itself isn’t disappearing. The code, databases, APIs, infrastructure, and distributed systems are still there. If anything, they’ll become more sophisticated and need to scale more than ever. What’s disappearing is the expectation that the creator must think like the machine.
For forty years we’ve taught people to use computers by learning applications and features. Need to edit a photo? Open Photoshop. Need a spreadsheet? Open Excel. Need to write? Open Word. Every task began with choosing software.
AI quietly reverses that relationship. The starting point becomes an intention.
“I want to launch a [insert {specific} business idea].””
“I want to redesign my kitchen to be [insert tasteful direction in {style}].”
“I want to compare [{health} insurance plans].”
“I want to write a [insert {concept for} story arc].”
The software figures out the rest.
AI doesn’t make software disappear, but rather, it hides it in the closet. It makes the software-centric mental model disappear.
The experience begins by sitting across from a bar-room philosopher over a drink. You riff on an idea. They ask socratic questions. They challenge your bias and elevate your thinking. What comes out is a sketch of possibilities you hadn’t considered. The interface becomes a multi-level conversation with tangents and redirects. And when the discussion shifts from colorful ideas to construction, conversation is still the only observable surface.
Beneath it, an extraordinary amount of software is coordinating APIs, generating code, querying databases, negotiating permissions, orchestrating services, rendering interfaces, and deploying infrastructure. None of that goes away. It simply recedes into the background, much the way a modern automobile hides fuel injection, transmission timing, and engine management behind a steering wheel and two pedals.
The magic isn’t that complexity disappears. It’s that complexity no longer burdens the user. And that changes who gets to create compelling things.
Before AI, the number of people capable of turning ideas into software products was constrained by the number of people who could write software. Tomorrow, the number of software creators won’t be limited by programming ability nearly as much as by imagination, taste, judgment, and persistence.
The creator class expands dramatically.
That doesn’t mean every idea will be good. Quite the opposite. Lowering the cost of construction increases the value of discernment by a lot.
As execution becomes abundant, good ideas and taste remain scarce. Understanding people remains scarce. Knowing which problem is actually worth solving remains scarce and very important.
For product designers, this may be the biggest shift of all. For decades we’ve designed interfaces: buttons, navigation, menus, dialogs, workflows. Increasingly, we’ll design behaviors instead.
When should an agent interrupt? When should it ask permission? When should it simply act? When should it challenge the user instead of agreeing? When should it remain silent?
Those are no longer interface questions. They’re relationship questions, and that’s the transition we’re living through.
The personal computer democratized computation. The web democratized publishing. The smartphone democratized distribution. AI democratizes construction. Not just software construction, but the act of taking an idea and giving it form.
The next generation of builders may never learn to code in the traditional sense. They may not know the difference between a REST API and GraphQL, or how a compiler optimizes a binary. They won’t need to.
Their comparative advantage won’t be syntax. It will be imagination.
The future belongs not to everyone who can program, but to everyone who can envision something worth bringing into existence.