This essay uses a ladder of defensibility: how hard your idea is for someone else to reproduce. The rest of this site uses a ladder of what to build: prompt, skill, connector, agent, app. They're cousins. The decision tool answers "what should we build for this?"; this essay answers "if we build it, can anyone else do the same by typing?"
An AI wrapper has a moat only if the smallest thing a competitor would need to reproduce to replace it can't be typed: if a prompt, a skill or a weekend clone would do it, the product sits below the Moat Line. The moats that lift you above the line are the old ones (data that compounds every time a customer uses you, a network built one user at a time, integrations customers can't rip out, and trust earned where being wrong is expensive), and AI didn't invent a new kind. To score your own product, take the wrapper risk test; to check an idea before you build it, see what AI idea validators can and can't tell you.
A growing share of the things people ask me to build are things they could do by typing a sentence into Claude. Not most of them, not yet, but enough that I've started keeping a tally in my head, and the tally is what made me want a way to sort the ideas before the kickoff call instead of three weeks into the build. Someone describes an app, and within about a minute I can usually hear whether it's a company or a feature wearing a company's clothes. I wanted to make that minute legible to the person across the table, instead of keeping it as a gut feeling I couldn't defend.
The gut feeling turns out to be tracking one thing. Every software idea sits somewhere on a ladder of how hard it is to reproduce, and there's a line on that ladder I've started calling the Moat Line. Below it, the thing that makes you valuable can be typed into existence, by the model itself or by a competent person with an afternoon; above it, it can't. The moats that put you above the line are the same ones they've always been, which is the part most of the panic skips over: AI didn't invent a new kind of defensibility or destroy the old kind, it dragged a huge amount of what we used to call software underneath the line, fast, while everyone was arguing about whether the demos were impressive.
What is the one-line moat test?
What's the smallest thing someone would have to reproduce to replace you, and can they just type it? That question sorts any software idea onto one of four rungs, and asking it before the build instead of three weeks into it is the difference between a cheap lesson and an expensive one.
What are the four rungs?
A prompt
At the bottom is the prompt. The whole product is one model call, and the model already does the job, so the honest version of the pitch is "I've put a text box around something you already have." This is where the summarizers and the rewriters and the extract-my-action-items tools live. Jasper was a billion-dollar version of this until GPT-4 shipped the same core feature for nothing and the floor went out from under it. If losing your API key would also kill your company, as the line going around puts it, you didn't build a product, you wrote a fancy prompt. To climb you add the one thing the model can't do alone.
A skill
One rung up is the skill. Here the value is a prompt with some packaging around it, a few instructions, a reference file or two, maybe a tool wired in, the thing you can now ship as a Claude Skill or a custom GPT. It feels heavier than a prompt because there's a config involved, but the config is the product, and a competent user rebuilds it in an afternoon once they've seen what it does. This rung barely existed two years ago, which is why so many people are standing on it convinced they've built something sturdier than they have. To climb, the packaging has to do something a copy of it can't, and a config file copies perfectly.
(If you're building a skill for your own team rather than to sell, none of this is a problem. Being easy to copy is exactly what you want from an internal tool. The pattern library is full of skills that are worth an afternoon precisely because they're cheap.)
A weekend clone
Then comes the weekend clone. Now there's a codebase, a database, an interface, an integration, the kind of thing that used to take a small team a quarter and now takes a good builder a weekend with Cursor or Claude Code. Pieter Levels built a browser flight simulator in roughly three hours with no game-development background and had something north of three hundred thousand players inside a couple of weeks. The catch is that the weekend buys you the demo, not the company, and the distance between those two is most of the work. It cuts the other way too: if a weekend reproduces your demo, the code was never your moat, and "mine handles the edge cases" won't save you, because the next person's Claude Code handles them too. The climb here is the steepest, from a thing that works to a thing that's hard to leave.
A system
Above the line sits the system. To replace you here, someone has to rebuild the things that took years to pile up and can't be typed, the data that compounds a little more every time a customer uses you, the network you can only assemble one user at a time, the integrations a customer can't rip out without rewiring half their stack, the trust you earn slowly in the places where being wrong is expensive. None of that has an afternoon version. You're here if a competitor with more money than you, who copied your software in full, still couldn't catch you, because the thing they'd need isn't in the code.
The four rungs, side by side
| Rung | What it is | Who can reproduce it | The tell | The climb |
|---|---|---|---|---|
| Prompt | One model call; the model already does the job | Anyone with the API | Losing your API key kills the company | Add what the model can't do alone |
| Skill | A prompt plus packaging, instructions, a reference file, a tool | A competent user, in an afternoon | The config is the whole product | Make the packaging do something a copy can't |
| Weekend clone | A real codebase, database, interface | A good builder, in a weekend with Cursor or Claude Code | A weekend rebuilds your demo | Turn the working thing into a hard-to-leave thing |
| System | Years of data, network, lock-in, trust | Nobody quickly, even with more money | A funded clone copies the software and still can't catch you | Keep the flywheel turning |
Is hard to build the same as hard to copy?
The part I had to correct in my own head is that the top rung is not about how hard the thing is to build. Hard tech buys a lead, not a moat, because difficulty is exactly what the tools are collapsing. The Samwer brothers cloned Airbnb's software in a few weeks and shipped it across Europe as Wimdu, funded north of ninety million dollars, and it should have worked on every spreadsheet. What they couldn't clone was the hosts and guests already on Airbnb, and that was the whole game. a16z put it in a line I keep coming back to: differentiation is not the same as defensibility. Complexity only turns into a moat when it compounds into one of the durable kinds, when the hard thing you built starts throwing off data or lock-in or scale the next builder can't catch no matter how fast they move. Until then it's a head start with a stopwatch running.
What are structural and kinetic moats?
There's a second kind of moat that never shows up on the ladder, because it isn't in the company at all, it's in you. Call the durable kinds structural: the data, the network, the lock-in, the trust, the things that keep working while you sleep because they live in the company and compound on their own. Against those, set the kinetic kind, the moat that's really just your own velocity, where you stay ahead of the weekend clone because you ship faster than they can copy, you read each new user better than they can, you already own the room the customers are standing in. It's a real moat, and plenty of good companies have run on it for years, but it's rented, not owned. It protects you for exactly as long as you keep moving, and the day you slow down it evaporates, because there was never anything underneath it but you. I wrote more about that split in kinetic vs structural moats.
This is the part the ladder can't grade on its own, and it's why the honest version of the question isn't only what's the moat but who's holding it. Two people pitch the identical below-the-line idea; one has spent six years inside the exact problem, owns the audience that has it, and will out-build any cloner out of plain obsession, and the other read about it on a Tuesday. Same rung, completely different odds, and the gap between them is founder-market-fit, which is just whether you're the person who can run the kinetic moat long enough to dig a structural one underneath it before your legs give out. A wrapper in the right hands is a wedge, and the same wrapper in the wrong hands is just a wrapper.
Does every AI startup start below the line?
None of this is an argument against starting below the line. Almost everything starts below the line. The studio I run has shipped things that were one decent idea above a text box, charged for them, and slept fine, because the wrapper was the wedge and not the destination. The mistake isn't building a wrapper, it's staying one long enough for the platform to ship your feature at its next demo day, which it will, because to them your product is a roadmap item. The ladder isn't a verdict on your idea. It's a map of where you're standing and which way is up, and up always means adding the one thing the model can't type for you.
So the question I now run on every idea, mine or a client's, before anyone writes a line of code, is whether it should just be a prompt, and if the answer is yes today, what would have to become true for it to be no in a year. Most people guess one rung too high, so when you're unsure, assume you're lower. If you're deciding what to build for your own team rather than what to sell, the decision tool runs the other half of that question, and it's usually a happier answer: for internal work, being cheap to copy is a feature.
Questions people ask
What is the Moat Line?
The Moat Line is the point on a four-rung ladder of software ideas where the thing that makes you valuable stops being something a model or a builder can type into existence. Below it sit prompts, skills and weekend clones, all of which a competent person can reproduce quickly with current AI tools. Above it sit systems whose moat is data, a network, lock-in or trust that took years to build.
Is building an AI wrapper a bad idea?
No. Almost everything starts below the line, and a wrapper can be a perfectly good wedge into a market. The mistake is staying a wrapper long enough for the platform to ship your one feature at its next demo day, because to them your product is a roadmap item.
Is hard-to-build the same as defensible?
No, and it's the most expensive confusion on the ladder. Hard tech buys a lead, not a moat, because difficulty is what the tools are collapsing fastest. Complexity turns into defensibility only when it compounds into data, a network, lock-in or trust.
How do I know which rung I'm on?
Ask what the smallest replaceable version of you is, then who could build it and how fast. If a model already does the job, you're a prompt; packaging a user could copy in an afternoon, a skill; a codebase a good builder could rebuild in a weekend, a clone; years of data, network or trust nobody can type, a system. Most people guess one rung too high.