AI Coding Agents for Product Managers: Preview, Comment, Steer

Published August 5, 2026 · by the AQ team

A product manager can work with AI coding agents through two kinds of tools as of August 2026: prompt-to-app platforms (v0, Lovable, Figma Make, Replit) where the PM builds and previews a prototype themselves, and production-codebase workflows where an agent like Claude Code or Codex makes the change in the real repository and the PM reviews it through a live preview with comments. The first lane validates ideas fast. The second changes what actually ships. What separates good setups from frustrating ones is not which model writes the code: it is whether the PM sees the running UI early, and whether their feedback reaches the agent without an engineer as courier.

Why product managers are in the coding loop now

Coding agents collapsed the cost of producing a UI change. What they did not change is who is best placed to judge one. Whether the empty state reads sensibly, whether the flow matches the intent, whether the copy sounds like your product: those calls belong to the PM or designer, exactly the people who will never review a unified diff. When agent output is only reviewable as code, the reviewers with the strongest opinions are excluded, and their feedback arrives after merge, as a bug report. So the practical question is a tooling one: what lets a PM see a live preview of the agent's work, comment on it in place, and have that comment become the agent's next instruction?

Lane 1: prompt-to-app platforms the PM drives alone

The fastest way for a PM to get a working preview is to build the thing themselves in a platform designed for it. As of August 2026, on each vendor's own description:

• v0 by Vercel turns natural-language prompts into full-stack Next.js applications with a live preview, and can deploy to production or open a pull request for review. No coding experience is required, per Vercel's own positioning.
• Lovable generates full-stack web apps from prompts and offers two-way GitHub sync: changes in Lovable push to your repository and changes made there flow back.
• Figma Make is Figma's prompt-to-app tool. Its distinctive feature is context: attach existing Figma designs and the model translates the layers into functional code, so prototypes inherit your design language.
• Replit Agent builds and deploys apps from prompts in the browser; Replit publishes a PM-specific prototyping guide and has said over half of its business signups are not engineers.

These tools share the property that matters most here: the preview is native. The PM describes a change, the running app updates, no engineer is involved. For validating an idea or walking into sprint planning with something clickable instead of a static mock, this lane is genuinely excellent.

The limit is the handoff. A prototype built this way lives in its own small codebase, not in your product. The production app has authentication, real data, a design system, tests, and CI; the prototype has none of them, so engineering rebuilds what the prototype proved. For throwaway validation that is fine (killing ideas cheaply is the point). It stings when the PM prototyped a fix to a real product screen: the change was fully specified, then re-done inside the actual repository.

Lane 2: steering agents that work in the production codebase

The second lane runs the agent inside the real repository: an engineer (or a PM working within team guardrails) points Claude Code, Codex, or another agent CLI at the codebase, and the change lands as a branch and a pull request. Now the PM's problem is visibility: the only artifacts are a terminal session and a diff, and neither is a PM surface. Teams solve it three ways:

• Ask the engineer for a demo. Works, but serializes everyone: the engineer screen-shares, the PM reacts, the engineer relays the reaction to the agent. Every round costs a meeting.
• Preview deployments with built-in comments. Vercel builds every pull request into its own preview URL, and comments are enabled by default on preview deployments on all plans: reviewers comment on the page itself, and click and drag to screenshot a region into the comment. Netlify's Deploy Previews pair with the Netlify Drawer: screenshots, annotations, screen recordings, and feedback that files into GitHub, GitLab, Jira, Linear and other trackers, with a free unlimited Reviewer role. Both as of August 2026.
• A shared live preview from the agent's own checkout. Run the dev server where the agent is working and give the PM the URL. This is what preview tooling for agent workflows covers in depth: it needs per-task isolation (usually git worktrees), a port per task, and a machine that stays awake.

Preview deployments are the most polished of the three, and the obvious answer if your app already builds on one of those platforms. Their constraints are structural: the app has to build and run on the platform (internal services and heavyweight monorepos often do not), the agent has to commit and push before anyone can look, and the comment thread is designed to end at a human assignee, not at the agent that wrote the code.

Feedback an agent can act on

However the preview is produced, PM feedback is only useful once it reaches the agent with enough context to act. A good preview comment names the page, the element, the state ("the empty cart, on mobile width"), and what was expected instead. A screenshot beats all of that, because the agent sees exactly what the reviewer saw. What kills feedback is the courier hop: a comment left on a preview platform or in chat has to be copied into the agent's prompt by a human, and every hop loses detail. Users are asking vendors to close exactly this gap (there are open requests to sync Vercel preview comments into GitHub pull requests specifically so coding agents can consume them, as of August 2026).

There is also a quieter reason to want PMs on agent previews: agent work rarely gets a second human at all. A July 2026 LeadDev analysis of 25,264 agent-generated pull requests across 2,361 popular GitHub repositories found that in 79 percent of agentic PRs the same developer both reviewed and modified the agent's contribution, and only about one in eight workflows involved multiple humans. A PM clicking through the preview is the cheapest second pair of eyes an agent workflow can get: no code literacy required, and it reviews the thing users actually touch. (For the engineering side, see how to review an AI coding session.)

Where AQ fits

AQ is the multiplayer coding harness where engineering teams run AI coding agents like Claude Code and Codex together: shared live terminals, a code editor, and app previews, in your own cloud. In this guide's terms, AQ is the fourth row of the table built into the product: every workspace gets its own isolated git worktree and can run a live dev-server preview from it. The PM opens the preview in the browser while the agent is still working, not after a push and a platform build, and it works for anything that can run a dev server on your team's VM.

The feedback loop is the point. Comments are pinned on the preview itself, and a pinned comment can be sent to the agent as its next prompt, so "this button is misaligned" lands in the agent's session without a courier. Teammates can attach screenshots to their comments. Preview share links are view-only and work without an account, so a PM can pass one to anyone; outside reviewers who should comment (a customer, a founder without a seat) use a review link and a quick email sign-in, without attachments. A PM who wants more than the preview can open the workspace itself and watch the live terminal: agents run as real CLIs in persistent tmux sessions on the team's VM, streamed to the browser on desktop or phone, and sessions survive a closed laptop. For teams that plan in Linear, AQ's Linear intake lets a PM label an issue ai-task and a workspace appears, status syncing both ways and ownership following the assignee; a human starts the agent, nothing auto-launches.

The Free plan is the full product on a VM you bring (you pay only your cloud provider); the Team plan is $100 per user per month (promotional; standard $200, billed monthly) with a dedicated always-on VM managed by AQ in its own isolated network, rate locked for your first 12 months.

Plainly: for validating ideas, use a prompt-to-app tool. AQ earns its place when the PM's opinion needs to land on the real change, in the real repository, while the agent is still in the session to act on it.