Yes, another AI post. But this one comes from a real problem, not from a LinkedIn thread.

I recently attended a Vercel event. One of the topics that kept coming up was something every tech team I know is dealing with right now: everybody codes. Product managers, designers, ops, marketing… they all have an agent that writes code for them. And they are using it. A lot.

As an engineer, I don’t love it. But as VP it’s my duty to enable others too. It also raises an uncomfortable question for those of us who are responsible for what runs in our companies: how do you manage all that code?

Reviewing at the exit

Someone at the event explained how they do it. They let teams build their own prototypes, and then an engineer reworks them completely before anything goes live.

The problem: who reviews all of that? The volume of code grows much faster than anyone could review, and thus, someone becomes the bottleneck.

Manual reviewing at the end is boring, expensive and almost impossible to do. By the time the code reaches you, every decision has already been made: the framework, the database, the auth, where the secrets live… And once something is built, there is a lot of resistance to waiting for others to build (properly) what you have already done.

“Reviewing” at the door

At Playtomic we had exactly the same problem. Our answer was to move part of that review to the beginning of the project instead of the end.

We gave non-technical teams a template and a set of skills. Together, they define everything we would otherwise check in a review:

  • The framework and the tech stack.
  • The design system.
  • Security requirements.
  • Coding conventions.
  • How secrets are handled.
  • How and where the app is deployed.

The result is that people are much more constrained. They can’t pick stuff they don’t know: their own stack, their own design system, their own infra, …

It sounds restrictive, and it is. But this way we don’t have to drop those prototypes completely.

Why v0 and Vercel

The template runs on v0 and deploys to Vercel.

These teams were already using Lovable, as it was the most intuitive for vibe coding. You write a prompt and you see what it generates, almost in real time.

On the other side, it has its own opinionated stack, built around the things Lovable does well.

We were already using Vercel for smaller projects. For starting a project, it’s hard to beat. Before you need to scale, Vercel gives you a lot of things that would otherwise require a fair amount of your own infrastructure.

The missing piece was a Lovable-style experience on top of Vercel. Then v0 showed up. It wasn’t as easy as Lovable, not even close at the time, but it deployed to Vercel. That was enough.

And now, not even v0

Tools have improved so much that many people no longer need v0 or Lovable. They open Claude Code and the agent does it all: it writes the code, starts the local server, and walks them through it.

The interesting part is that most of the decissions were in the template and skills, not in the tool. We also added a security agent on the PRs that double-checks our security guidelines and constraints.

The final human check is still there, of course. Someone still has to say “this goes to production”, but the review is way faster.