The Moat Line: what AI made cheap, and what it didn't

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.

The four rungs

The ladder has four rungs, and the question that sorts an idea onto one of them is one line: what's the smallest thing someone would have to reproduce to replace you, and can they just type it?

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.

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 eighteen months ago, which is why so many people are standing on it convinced they've built something sturdier than they have.

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.

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.

Hard to build is not the same as hard to copy

The part I had to correct in my own head is that this 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 as Wimdu; 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.

Two kinds of moat: structural and kinetic

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.

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 weekend clone beats a tourist. It does not beat someone who was always going to outwork it. That's the real reason the tool asks who you are and not only what you're building, because a wrapper in the right hands is a wedge, and the same wrapper in the wrong hands is just a wrapper.

Almost everything starts 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. I built a small thing that runs the question for you at shoulditbeaprompt.com. You describe the idea, it tells you the rung, and then it proves the verdict by handing you the prompt or the skill that would replace you, which will be either the most useful or the most irritating thing you read this week, depending on where you land. I'd rather you find that out now than three weeks into the build.

Common questions

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 the line sit prompts, skills, and weekend clones, all of which a competent person can reproduce quickly with current AI tools. Above the line sit systems whose moat is data, a network, lock-in, or trust that took years to build and can't be typed. AI didn't move the line, it dragged most of what we used to call software underneath it.

Is building an AI wrapper a bad idea?

No. Almost everything starts below the line, and a wrapper can be a perfectly good wedge to get into a market cheaply. 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. A wrapper is a starting position, not a destination.

What makes an idea defensible in the AI era?

Defensibility comes from the things that can't be typed: a data flywheel that compounds every time a customer uses you, a network you can only assemble one user at a time, integrations a customer can't rip out without rewiring half their stack, and trust earned slowly where being wrong is expensive. Hard-to-build is not the same as defensible, because difficulty is exactly what the tools are collapsing. The other half of the answer is founder-market-fit, since below the line the person running the idea is often the only moat the tools can't clone.