A New Class of Software Builders is Emerging.

Software powers every industry, yet its creation is limited to a small pool of experts. There are only about 30 million professional developers worldwide, and it takes years to train each one [Sequoia: 1]. This bottleneck stifles innovation – we simply “cannot yet create software at the speed of our imagination” [Sequoia: 2]. Generative AI now offers a chance to break this barrier. 

Generative AI is lowering the barrier to software creation, enabling “tons of code to be generated by people who are not otherwise coders” [Reid Hoffman: 3]. In other words, non-technical individuals with ideas – from kids and creators to solopreneurs and business operators – can increasingly build software without traditional coding [NYT: 4]. Evidence of this shift is growing; everyday consumers are for the first time able to build fully interactive apps (not just simple websites) using AI-driven tools [a16z: 5].

For example, a designer (with no formal coding background) built a mobile game using only natural-language prompts on an AI-powered platform [a16z: 6]. Another creator has launched over 3 apps generating over $200K independently using AI-assisted coding [Product Hunt: 7]. 

These early signals show AI unlocking software creation for new builders who previously “would [not] leverage code in their work” without a steep learning curve [Reid Hoffman: 8]. Even in instances where people who know how to code will begin to lean more on AI to write the code for them. It is predicted that by 2026, all code will be AI generated [Anthropic: 9]. 

Sequoia Capital calls AI-driven software creation “the greatest compound lever in human history” [Sequoia: 10] because it can turn natural language into working software, effectively multiplying developer capacity. The ability for non-technical creators to build software was estimated at $3.83B in 2023 and is projected to grow at a CAGR of 30.6% from 2024 to 2030 resulting in a $30.41B market by 2030 [Grand View Research: 11]. 

Despite the criticism surrounding “vibe coding” [Bloomberg: 12], revenue at platforms targeting non-technical individuals like BOLT (ARR $20M – 2 months after launch) and Lovable (ARR $17M – 3 months post launch) [FT: 13] – indicating now is the moment to seize this opportunity. 

Current AI coding platforms aren’t ready for the next leap in software development. Tools like GitHub Copilot, Cursor, and Replit focus on developer productivity, not on helping users build high-quality, production-ready software. Even Bolt and Lovable, which try to abstract away complexity, still require users to manage engineering tasks like starting servers, wiring APIs, and running tests.

The core issue is a bias toward instant gratification over long-term quality. These tools operate in narrow context windows, often ignoring broader architectural goals. This leads to broken integrations, overlooked security, mismatched coding patterns, and skipped testing—even when the full codebase is indexed.

If AI is to empower a new generation of non-technical builders, it must take responsibility for the hard parts of software creation. AI needs to evolve from code-completion assistants to software-orchestrators: handling architecture and quality safeguards invisibly, so users can focus on what they want to build, not how to build it. Only then can we unlock the full creative potential of AI in software.

The Next Wave of Software

We’re at the end of a cycle. Most categories of software—productivity, collaboration, commerce—have already been built and rebuilt. What’s left isn’t more of the same. It’s something fundamentally different: software created not by developers for the masses, but by individuals—for themselves, their communities, their values—and the systems they’re embedded in.

1. Deeply Personal
   Software becomes an extension of the self.
   
   Software is about to get extremely personal [YC/Garry Tan: 14] where people will build tools for themselves—habit trackers that reflect their neurodiversity, journaling apps tuned to their emotional rhythms, or a personal intelligence feed delivering daily briefings. Software will become an extension of the self.
   
   Why it matters: Millions of parents, caregivers, and individuals have unmet needs that will never justify commercial product-market fit—but AI lets them solve those needs anyway.
   
   

2. Culturally and Contextually Local
   Software that speaks your language, literally and figuratively.
   
   Mainstream platforms ignore the nuance of language, culture, and context. With AI, anyone can build tools in their native language, shaped by local customs and lived realities—whether it’s an indigenous language dictionary app or a region-specific health app to tackle well-being [arXiv: 15].
   
   Why it matters: 90% of the world doesn’t speak English natively, and entire markets are underserved. AI dramatically lowers the cost to localize, unlock, and monetize these regions.
   
   

3. Interconnected and Modular
   Software built like workflows, not products.
   
   Instead of monoliths, people will compose software like Lego [NY Post: 16]—stitching together calendars, chats, workflows, and content using natural language. AI becomes the interface layer that bridges disconnected tools into something entirely new.
   
   Why it matters: Solopreneurs and creators now operate as micro-enterprises. Modular AI tooling lets them automate operations, reduce spend, and increase revenue—all without touching code.
   
   

4. Temporal and Situational
   Software built for moments, not markets.
   
   Software won’t need to be permanent to be useful. People will spin up apps for events [Glide: 17], projects, campaigns, or communities that last a weekend or a season.
   
   Why it matters: Millions of short-lived events (conferences, crises, local campaigns) have no software today because the cost to build is too high. AI collapses that cost to near-zero.
   

5. Value-Aligned and Mission-Driven
   Software that reflects belief over business.
   
   Without the pressure to scale or monetize, people will build software that reflects their beliefs—tools designed around faith, ethics, accessibility, activism. The constraint of “addressable market” dissolves when the builder is the user [Time: 18].
   
   Why it matters: As trust in big tech erodes, people want software aligned with their ethics. AI allows small teams and solo builders to compete on vision, not just capital.
   
   

6. Knowledge Worker Focused
   Knowledge workers stop waiting on IT.
   
   Knowledge workers inside large organizations will stop waiting on IT. AI will let analysts, designers, PMs, HR teams, and operations leads build zero-to-one products adding to new or existing revenue streams. Even internal tools—dashboards, onboarding flows, data pipelines—tailored to how they actually work. Software becomes a layer of adaptability inside rigid systems [Microsoft: 19].
   
   Why it matters: This reframes software as a dynamic expression of your own existing software and data stack, unlocking use cases at the edge of LLMs and embedded intelligence for employees who would otherwise have to wait on Engineering partnerships for any real impact.  

Clayton Christensen’s Jobs to Be Done theory and Eric von Hippel’s Democratizing Innovation framework reveal a consistent truth about software: when the tools to build get easier, innovation shifts to the edges. The most meaningful software yet to be built will come not from existing power users, but from non-consumers—people who’ve never had access, until now.

We’ve seen this play out before. Shopify made it radically easier for anyone to launch an online store without writing code—today it's valued at over $140 billion. Canva did the same for design, unlocking brand-building for millions who couldn't afford professionals—its latest valuation sits at $49 billion. Both platforms proved that empowering non-experts can unlock massive markets.

AI is now doing for software creation what these platforms did for commerce and design. It doesn’t just unlock new products; it enables entirely new categories of software that were previously unimaginable.

Build the Rails, not the Train 

To empower a new generation of builders, we must go beyond simple code generation, as platforms like GitHub Copilot, Cursor, and Replit currently do. We need to abstract the entire software creation lifecycle and automate the process for non-experts. Today’s AI tools are merely autocomplete engines; the next step is to develop a Software Creation OS—an autonomous system that manages everything from concept to deployment. You should be able to provide an idea, step back, and return to a finished product. This vision is the north star, but to move quickly and validate this hypothesis, we must focus on what to exclude and prioritize the essentials.

1. Don’t Build Models. Build the System Around Them.
   Model performance is no longer the bottleneck. OpenAI, Anthropic, and others have made high-quality code generation widely available. Competing here is a distraction. All current models are powerful enough to generate high-quality code—if given the right context.
   
   The opportunity is not in model R&D—but in orchestrating the end-to-end system around agnostic models to ensure consistent, usable, high-quality software outcomes.
   
   

2. Fix the Architectural Gap. From Single-Shot to Systems Thinking.
   Today’s tools can build single-feature demos—but they break down at multi-step workflows and interconnected logic. What’s missing is architectural continuity—the ability to understand a user’s macro goal (e.g., “build an Airbnb for car enthusiasts”) and recursively break it down into isolated, testable, yet connected systems; through continuous integration into the codebase.
   
   We need a system that understands the full application architecture from the beginning—breaking down features, managing complexity, and enforcing best practices at every layer.
   
   

3. Make it Autonomous. Let the User Step Away.
   Most current tools are assistive, not autonomous. They require constant user input, frequent debugging, and manual deployment.
   
   Intent Parsing: Understand what the user wants to build
   Feature Analysis & Decomposition: Auto-generate a roadmap and break down features.
   Code Generation & Assembly: Build modular code aligned with the architectural plan.
   Parallelization: Work on interdependent things in parallel, offline.
   UX Design & Layout: Auto-layout visually pleasing UIs without user intervention.
   Security & Testing: Inject automated QA and security auditing as defaults.
   Feedback Loops: Let users tweak vision, not syntax.
   
   Today, the AI asks: “What code do you want?”
   We need to build a system that says: “Here’s a v1 ready to test.”
   
   

4. Production-Grade by Default.
   Today’s AI output is fragile, inconsistent, and unscalable. Production quality is an afterthought. If you know how to read code, the success of you getting a successful outcome is high. That might not be the case for non-experts currently “vibe-coding” their way through apps. This process is riddled with bugs and poor-quality code.
   
   We must define quality as: Does this app work well enough to launch without an engineer touching it? That is the bar. Nothing less.

5. Continuous Co-Creation. Not One-Shot Prompts.
   Building software is iterative. Users need to evolve ideas, add features, and incorporate feedback over time.
   
   The system must stay in sync with user intent—tracking goals over time, refining outputs, and continuously improving apps without rewriting from scratch.

What’s Missing from the Current Stack?

When focusing on the problem of ‘letting non-experts have a personal CTO to build anything they can imagine without having to dive into the technical nuances of software,’ one must begin by understanding where the current stack’s maturity lies—and where it still fails.

Orchestration
Today’s foundation models are relatively capable orchestrators, but they require deliberate, continuous guidance to deliver useful outcomes. Despite viral one-shot claims [X], complex apps cannot reliably be built with a single prompt [X] [X]. The models lack persistent strategy, holistic system design, and architectural discipline. Startups focused on developer productivity are mostly ignoring this deeper orchestration challenge. This gap is where we build.

Memory
Models today simulate continuity but do not retain it. They cannot recall what features a user has previously scoped, which designs have been approved, or how APIs have been structured in past projects. A robust memory system must anchor each session to a persistent project state, tracking architectural intent, naming conventions, error histories, and revision decisions—serving as the source of truth for an evolving software system. Without this memory layer, co-creation is impossible.

Context
Current models operate within narrow context windows—typically a few thousand tokens. This forces systems to work with incomplete visibility and frequently drops critical system-level knowledge, such as schema definitions, prior UI flows, or user preferences. The solution is a dynamic, intelligent context engine: one that retrieves relevant artifacts (code, design, logic, past decisions) precisely when needed, maintaining coherence across sessions and features.

Tools
The existing toolchain is fragmented, requiring users to hop between siloed environments—GitHub for code, Figma for design, Postman for APIs, Vercel for deployment. Each tool assumes technical fluency and manual handoffs. We envision a toolchain unified by agents—each specializing in a domain yet governed by a shared architectural vision. These agents communicate, collaborate, and course-correct together. AI acts not as a patchwork assistant, but as the connective fabric of a seamless, end-to-end software creation experience.

What hasn't been proven, yet?

We can’t solve the entire software creation lifecycle on day one. Doing so would demand a massive investment in time, talent, and infrastructure. Instead, we focus on what must be proven to validate our hypothesis and unlock the next wave of AI-driven creation.

The central challenge is orchestration. It is not enough to generate isolated features or static UI components. We must demonstrate that agents can reason together across functional boundaries—UX, backend, database, infra—and deliver coherent, testable systems. This orchestration capability is the keystone: if we prove that, we prove that autonomous software creation is possible.

Memory and context are accelerants, not prerequisites. To succeed, we don’t need perfect long-term memory or unlimited context windows. What we need is a working prototype of task-level retention: the ability to track decisions across the build process, pass state between agents, and retrieve relevant info when needed. Enough to scaffold continuity, guide regeneration, and avoid breaking architectural assumptions.

By narrowing scope to orchestration, memory, and context within a defined surface area—say, 3–5 modular features—a small team can prove the viability of the system while learning how each layer compounds value.

This isn’t about shipping an app. It’s about demonstrating that agents can architect, coordinate, and iterate on software systems with minimal user intervention. Once we prove this kernel, everything else becomes an exercise in scale.

What’s Next

A Cambrian explosion of software is about to begin—not led by engineers, but by everyone else.

The next billion apps won’t come from Silicon Valley. They’ll come from teachers building classroom tools, parents designing care trackers, local organizers spinning up civic platforms, and creators turning audience into infrastructure. Software will no longer be something you download. It will be something you describe.

This is the shift: from developer-led engineering to idea-led creation. From building with code to building with intent.