Prompting Scales. Verifying Doesn't. Yet.

I've been thinking about something Balaji Srinivasan wrote in June: prompting scales, because prompting is just typing, but verifying doesn't scale, because verifying requires much more than typing. The more I sit with this idea, the more I realize how often I run into it myself. Prompting feels fun and light. Verifying feels heavy and draining.

When I first started using AI in my work, the prompting part was magical. I could ask it to migrate a React component to Preact, and it would hand me back something that looked usable. Or I'd ask for a Jest test suite, and in seconds, I had scaffolding that would have taken me the better part of an afternoon to put together. Prompting felt like sketching with a collaborator who never ran out of ideas.

But the problem was that prototypes lie. They look finished, but they're not. The function might compile, but only barely. The tests run, but the assertions don't mean anything. The citations look neat and professional, but half of them are hallucinated. I found myself celebrating the output at first, only to sink hours into making it real. The bottleneck wasn't generating — it was verifying.

At some point, I realized this was unsustainable. I could prompt faster and faster, but my verification speed wasn't improving. If anything, the more the AI gave me, the more buried I became. So I started experimenting with layering different kinds of help. Linters and type-checkers could catch the trivial errors before I even looked at the code. Schema validators could reject bad payloads. I could ask one model to generate and another to critique, which saved me from wasting energy on nonsense. And instead of trusting the AI's output, I began running it through test harnesses: Lighthouse audits, a11y scans, sandboxed execution. What failed, failed fast.

Slowly, I built a kind of gauntlet. AI-generated code would go through automated guardrails, then cross-checks by other models, then pipelines with pre-commit hooks and Slack summaries. By the time anything reached me, most of the noise had already been filtered out. I wasn't drowning in mistakes anymore. Instead, I felt more like a judge. My role wasn't to catch every typo or broken line; it was to make the final call on what survived.

What surprised me was how much lighter that felt. It wasn't just about saving time, although it did. It was about shifting my role from being the AI's proofreader to being its reviewer. And that, strangely, felt like progress.

Balaji's point is true: prompting gets you started, but verifying gets you shipped. If you only ever prompt, you stay in demo-land. You build shiny things that look good in screenshots but never make it into production. If you invest in verification, you can actually ship. It's not perfect. It's not magic. But it's better than where I started.

And maybe that's the real lesson: AI isn't just about prompting faster. It's about designing systems that make verifying bearable. Because prompting is easy. Verifying is hard. And scaling verification — that's the challenge worth working on.

---

*Originally published on [Substack](https://venkatavemuri.substack.com/p/prompting-scales-verifying-doesnt).*