Andrej Karpathy wanted to control his smart home. Lights, HVAC, pool, spa, security cameras, audio. Six different apps from six different vendors, each with its own interface, its own login, its own idea of what “automation” means. The normal solution is to accept the friction. The new solution is to build something better in an afternoon.

He called it Dobby. A single WhatsApp-accessible agent that scanned his wireless network, found every connected device, and unified control behind a conversational interface he already used. Six apps became one. The interface became language. The friction became almost nothing.

That is not a productivity hack. That is the beginning of something different: software that belongs to you.

Software Has Never Been Personal

We have had personal computers for forty years. The word “personal” was always a lie—personal in the sense of individual ownership, not individual fit. The software running on those computers was designed for everyone, which means it was designed for no one in particular. Every Photoshop user gets the same Photoshop. Every Slack user gets the same Slack. The product teams make reasonable bets about what most users need most of the time, and the rest of the needs go unserved.

This was always a constraint of economics, not design intent. Custom software is expensive. A system built precisely for how you work, tuned to your habits, connected to your specific tools and data—that has always cost either a lot of money or a lot of time. Enterprise companies buy custom software and still pay millions for it to be wrong. Everyone else adapts to whatever shipped with the most comparable monthly subscription.

Karpathy framed this moment clearly. We are moving from Software 1.0—code written by engineers—through Software 2.0—neural network weights—into Software 3.0, where prompts written in English are the programs. The LLM is the runtime. Natural language is the interface. And if language is the interface, then anyone can build.

Vibe Coding Changes the Math

The term Karpathy coined in early 2025 is telling: vibe coding. You describe what you want and get working software. Not a prototype. Not a rough approximation. Working software. He built iOS apps without knowing Swift. He built a restaurant menu image generator, MenuGen, in hours rather than the weeks a traditional developer would need.

The actual coding became trivial. The deployment infrastructure remained complex—Google OAuth integrations still require clicking through seventeen configuration screens—but the core act of expressing software in code crossed a threshold. Anyone who can describe what they want clearly enough can get it built.

This is the inflection point the Dobby story illustrates. Karpathy did not buy a home automation platform or wait for some company to build the multi-vendor dashboard he wanted. He described the system he needed and built it himself, in the time he would have previously spent reading product documentation and filing support tickets.

The bottleneck is no longer building the software. It is knowing clearly enough what you want.

The App Store Was an Intermediary

Every app in a store is a bet. A team of people decided that enough users shared a similar enough problem to justify building a general solution and charging for access. The store model created the intermediary layer we now navigate constantly: you have a specific need, you find the app that comes closest, you adapt your behavior to fit the tool rather than the reverse.

This works well when your needs match the developer’s assumptions. It works poorly at the edges, which is where most of us actually live. The to-do app that almost fits your workflow. The note-taking tool that has most of what you need and the one feature that is inexplicably missing. The habit tracker that sends notifications at the wrong time, in the wrong way, and has no option to change it.

Each of those friction points persisted because the economics of custom software made the alternative unreachable. That constraint is dissolving. When building the app that exactly fits how you work costs an afternoon instead of a quarter, the calculus changes entirely.

Personal Software Requires Personal Clarity

What emerges on the other side of this shift is not just more software. It is different software. Software that knows your context because you gave it your context. Software that connects to your actual systems—your calendar, your notes, your home, your data—rather than a generic API that works for everyone and therefore for no one specifically.

Karpathy’s agents run in tmux grids, managing code repositories. His home automation agent knows the layout of his specific house. These are not products. They are tools with a user base of one, optimized for that user without compromise.

This changes what it means to be technically skilled. The engineers who will build the most valuable things are not necessarily the ones who can write the most efficient code. They are the ones who can describe problems with enough precision that an agent can solve them, who can design systems with enough clarity that the implementation follows directly from the spec. I wrote about this in the context of specifications becoming the real source code—the judgment about what to build is where the hard work lives. The building is increasingly automatic.

But this capability is not restricted to engineers anymore. The five-to-ten year learning curve that once stood between an idea and working software is collapsing. Anyone who can articulate what they need precisely can build it. That is genuinely new.

What Comes After Apps

The consumer software market as it exists—millions of users paying subscriptions for software that fits most of them well enough—will not disappear overnight. There are products where the network effect is the product. There are categories where the general solution is actually the right solution. And there are problems that require the kind of deep domain expertise that a product team accumulates over years and that a single person building their own tool will not replicate.

But at the edges, where your specific needs have never been served by the general solution, the era of personal software has started. The six-app dashboard becomes one agent. The to-do system that almost fits becomes one that actually fits. The workflow that required three tools and a spreadsheet becomes software that understands your workflow.

Software used to be designed for everyone. It is starting to become possible for it to be designed for you. That is a larger change than it first appears—not just in how software gets built, but in the relationship between people and the tools they use to work and live.

Personal computers were personal in name. Personal software might be personal in fact.