AI App Builders for Product Teams: A CPO's Field Notes

Engineering used to ask for more time. Now they're asking for better specs. That's not a complaint — that's the signal that the job of product management just changed. When agents are writing the code, the bottleneck moves upstream. The teams that figure out how to hand engineering deep clarity — a tight spec, a working prototype, a shared mental model — will be the ones that actually benefit from the speed. The tools in this article are how you do that.

I've mostly been living in Codex for my hobbyist code, but after talking with a number of CTOs about how Product can stay ahead of rapidly accelerating engineering teams, I decided to properly test the tools they kept mentioning: V0 from Vercel, Lovable, and Netlify's new app-building service. For a focus, I chose Avalara, which my wife uses for tax support for her augmented-reality jewelry business — and prototyped a simple app that calls the Avalara API to retrieve transactions.

Rolling Your Own with Codex

I first built the app using 'bare' Codex. Getting a basic app up and running wasn't hard:

Codex is nicely opinionated at the code level, but the moment you want a polished web app you need to be quite specific. For example, it proactively created a decent data table but omitted pagination and a query form. Getting those added was blindingly fast compared to dusting off my own JavaScript front-end skills — though it did take a little back-and-forth to get everything right. The default styling was only passable, but a single sentence prompt was enough to restyle the whole thing to match the Avalara UI.

Codex requires you to bring your own taste: layout, interaction patterns, and UX.

Codex shines most when a PM is embedded in a technical team and wants to contribute to the codebase, not just build isolated prototypes.

Building in V0

Vercel has been generating code for more than ten years. From a simple prompt it quickly produced an attractive application:

The formatting and the elegant filter form were entirely V0's idea — though much of the credit goes to the underlying model, which is, again, Codex. V0 was the first service to exhaust my free credits; the entry-level plan runs $30/month. It has a more technical and sophisticated feel and calls for a bit more developer awareness than Lovable. The frontend? Genuinely impressive. But V0 has limits on the backend — if your prototype needs real backend logic, it alone won't get you there. For UI-heavy validation, stakeholder demos, and anything that needs to feel real before a single line of production code gets written, it's currently the sharpest tool in the PM's kit.

Lovable

From a single sentence prompt, Lovable produced this attractive analytics dashboard:

The Lovable app is easy to use and arrived immediately with design ideas I would have needed a dedicated UX designer to nail on my own. But the more interesting thing about Lovable isn't the output — it's the philosophy. Lovable understands that the PM's job isn't to build software, it's to reduce uncertainty before software gets built — and it's designed around that loop rather than treating PMs as secondary users of a dev tool.

Netlify

I also tried Netlify's new app-generation service, which delivered similar results. Given that these frameworks share the same underlying coding models, that's no surprise:

Netlify makes the most sense for PMs embedded in engineering teams at companies already on Netlify, where the goal is prototypes that don't require a rewrite to ship.

Same Engine, Different Philosophy

Feature sets are converging rapidly — unsurprising given that these platforms are all drawing on the same small set of underlying coding models. V0 recently added automatic storage, matching Lovable in letting builders ignore that concern entirely. Netlify was code-only until recently but now offers the same front-end agent-building experience as the others. When the outputs look this similar, the differentiator isn't the tool — it's the clarity of thinking the PM brings to it.

A few real differences do stand out. Lovable preserves the full chat history — as you'd expect from a product born entirely in the post-ChatGPT era. When you reopen V0, the chat is gone; the code is the only artifact that persists. That's not just a UX detail — it reflects a fundamentally different assumption about who's driving. Lovable assumes the PM is the author. V0 assumes the developer will take it from here.

Hosted vs. Host It Yourself

The most interesting question for me: is it worth paying the app builders rather than going bare with Codex or Claude?

The biggest gap in a bare Codex build is hosting. Codex makes running locally easy, but you still need enough familiarity with localhost to start and stop your own app on a local port:

The moment you want to collaborate, localhost becomes infeasible from both a management and security standpoint. I suspect most product and engineering teams will find it worth paying Lovable or Vercel for the same reasons they pay Figma, Canva, and Lucid — the value isn't just the tool, it's the shared environment.

Anthropic and OpenAI have shipped a tremendous amount over the past year, and I'm curious whether they'll keep pushing up the stack into app-building. Claude Artifacts is a lightweight hosting solution of sorts, though it currently lacks persistent storage and the ability to make external API calls. OpenAI's Agent Builder shows an interest in moving up the stack, though their recent signal toward tighter focus may trim that ambition.

Organisational Considerations

For product teams, the most important factor when choosing a prototyping platform is what your engineering team is already using — or wants to use. Engineering is moving faster than ever. Agents are writing the code. The constraint isn't capacity anymore — it's the quality of what product hands over. A PM who shows up with a working prototype and a tight spec compresses weeks of back-and-forth into hours. A PM who doesn't is about to find out they're the bottleneck.

That makes toolchain alignment a strategic decision, not a preference. It makes little sense for product to build in Lovable while engineering uses V0 — the capability gap is too small to justify a split. Pick the tool your engineers respect, learn it well enough to hand them something real, and revisit the choice in six months. This space moves fast.