Building working software without writing code

I have spent my whole career in technology without writing code. For most of that time, this was a wall with a door in it: I could see what should be built, describe it, advocate for it, but someone else had to build it. The interesting thing about the last two years is that the wall quietly fell over.

I now have real, working software on my GitHub: an AI landing page builder that runs six specialized agents, a CLI tool that measures how often brands appear in AI model answers, and a system that detects potholes using smartphone sensors. AI agents did the typing. I did everything else. These are notes on what "everything else" turned out to be.

The scarce input moved

When generating code was expensive, the scarce input was engineering time, and the whole industry organized around protecting it. Now the generation is nearly free, and the scarce input is knowing what to build, for whom, and what good looks like.

This is, inconveniently for me, the part I'd been practicing for fifteen years without knowing it. Years of support tickets, merchant onboarding, and community questions are a long education in what people actually need versus what they say they need. The agents don't have that. They will cheerfully build the wrong thing with perfect syntax.

What the work actually looks like

Specification is the new literacy. The quality of what I get is a direct function of how precisely I can describe the job: the user, the workflow, the edge cases, what done means. Vague prompts produce confident, vague software. My old PM habit of writing things down before meetings turned out to be the core skill.

Review like a PM, not a compiler. I can't audit the code line by line, so I audit behavior relentlessly: run it, break it, feed it garbage, check the edge cases I specified. I also make the agent explain its choices in plain language and challenge anything that doesn't survive the explanation. It's the same trust-but-verify I'd apply to any team I couldn't micromanage.

Small scopes, always. When I ask for a system, I get a plausible mess. When I ask for one capability with a clear test of done, I get something I can verify and keep. Every project on my GitHub was built as a chain of small, checkable steps. This is just good product development; the agents simply punish you faster for skipping it.

Know what you can't verify. I don't ship things whose failure I can't detect. A landing page generator can fail in front of me; I'll see the bad page. That honest boundary matters more, not less, when the typing is free.

What this means beyond me

I think about the shopkeepers I grew up among, people with twenty years of customer knowledge and no way to turn it into software. The barrier was never insight. It was the translation layer, and the translation layer just became a conversation.

I don't know exactly what the world looks like when domain knowledge compiles. But I notice that the question "can you code?" is quietly being replaced by a better one: do you know what's worth building? That question has no API. You answer it with your biography.