Stop Asking ‘Can AI Build This?’ Ask ‘Can I Specify This?’

For a long time, whether you could build software came down to one question: can you write the code?

That question is mostly gone now. AI knocked down the syntax barrier. You can describe what you want and get working code back. So the natural next question becomes "Can AI build this?"

I think that's the wrong question.

The better one is "Can I specify this?"

The hard part moved

AI didn't remove the hard part of building. It moved it.

The bottleneck used to be syntax — knowing the language, the framework, the exact incantation. Now the bottleneck is specification. Can you define the problem, the constraints, the workflow, and the milestones clearly enough that an agent can actually execute?

That's a real skill, and it's the one worth developing right now. It's also the one most people skip, because it doesn't feel like "building." It feels like thinking. But the thinking is the building now.

A vague idea vs. a handoff-ready spec

Here's the difference in practice.

"Build me an invoicing app."

That's an idea, not a spec. An agent will build something from it — and then you'll spend the next two hours re-prompting, because every decision you didn't make, it made for you.

Now compare a handoff-ready version. What does the invoicing app actually do? Who uses it? What are the constraints — which fields are required, what happens when an invoice is overdue, what does it integrate with? What does "done" look like for the first milestone versus the third?

That's a spec. An agent can build from it without guessing. And when it does guess wrong, you've got a clear reference to correct against — instead of a moving target.

The system I use

The way I do it is a simple pipeline: raw idea → structured PRD → milestones → agent build → review.

The raw idea is the brain-dump. The PRD turns it into a structured document — problem, users, constraints, what's in and what's out. Milestones break the PRD into chunks an agent can build and you can review one at a time. Then the agent builds a milestone, you review it, and you move to the next.

The PRD and the milestones are where your judgment goes in. That's where you make the decisions that need taste. The build step is where the agent does the work that used to need syntax.

Specs reduce re-prompting because they front-load the decisions. Every constraint you write down is a round-trip you don't have later.

This is the graduation

This is what graduating from vibe coding into reliable building actually looks like.

Vibe coding got a lot of people to a v1 that worked-ish and then broke. I get why — when the syntax barrier drops, the first instinct is to just keep prompting until something appears. That works until it doesn't.

The shift is to put your effort upstream, into the spec, where it compounds.

So stop asking whether AI can build it. For now, assume it probably can.

Start asking whether you can specify it. That's the part that's still on you — and it's the part worth getting good at.