Originally published on butterneck.com.
AI coding tools have made a new question very real: should product managers ship code? Some teams are already trying it. Others are watching nervously. And engineers are asking who will review all of it.
This post looks at what the current debate is actually about, what recent data says about the review side, and a middle ground that gets PMs their small changes without handing them commit access.
PMs shipping code, in short: Building is getting cheap, but deciding what ships is still the hard part, and most PMs do not need to write code to get small changes made. With Butterneck, which runs on the developer's computer with the coding agent they already use, a PM asks for a change on a live copy of the app, Butterneck does not commit, push or open a pull request, and a developer decides first what ships; Butterneck never merges or deploys.
The debate, in plain terms
Guy Mor at H&B described on LinkedIn how his team is starting to let PMs use tools like Codex to make small changes to production systems. Their flow is careful: the PM identifies a simple change, uses AI to create a technical plan, an engineer reviews the plan, the PM uses AI to implement it, an engineer reviews the merge request, and then it goes to production.
He is honest that it is not simple. Two questions stood out:
- What exactly is a "simple change"? A PM may see a small UI tweak. An engineer may know it touches three other things.
- Are engineers being freed up, or turned into "people who review an endless stream of AI-generated merge requests"?
Jeff Gothelf comes at it from the other side in How to manage the inevitable mess of running a company where everyone is a builder. His first suggestion: "Keep the right to build separate from the right to ship." Anyone can build and show a prototype. Getting it in front of customers follows a path with evidence at each step.
At SDLCAI 2026, Viljami Kuosmanen described how epilot let non-engineers use coding agents on its production codebase. People tag an agent in a Slack thread, get a pull request and a preview link, and an engineer reviews it; product, design, support and QA all contributed. According to the conference's summary of the talk, an attempted production deployment was caught by monitoring, after which the team separated contribution, merge, CI and production permissions. More proposals also meant more review and testing, and he said he doesn't yet have strong data that delivery got faster.
The same tension shows up outside the product codebase. In Everyone's a software engineer now (LeadDev, 16 November 2026), Chris Stokel-Walker cites a Retool survey of 817 people building software: 60% had built something outside IT oversight in the previous year. Christina Troy of Tines puts the answer plainly: "Employees need guardrails and frameworks within which to build, and IT teams need to have visibility from the outset of these builds."
Product analytics companies describe the same shift. Mixpanel's CEO Jen Taylor, on its A/NZ Product Intelligence Index 2026: "three in four now say deciding what to build takes longer than building it" (ARN, 17 November 2026). Amplitude's Wave agent turns product data into plans for coding agents, and even there, "most teams send bug fixes straight to coding agents, while new features and bigger bets get a human review" (OpenAI, 12 November 2026).
They all land in a similar place. Building is getting cheap. Deciding what ships is still the hard, valuable part.
Some tools now go a step further and pitch that whoever spots a problem ships the fix, even from a phone. Our view is different. The PM asks and sees the change on a live preview. A developer decides whether it ships, and anything touching data models, permissions or payments goes to an engineer from the start.
What the data says about review
The engineers' worry has numbers behind it now. A Harvard study by Fiona Chen and James Stratton ("Artificial Intelligence in the Firm: Bottlenecks in Software Production", version of 14 Nov 2026) looked at 720,542 workers at 655 firms using data from the Jellyfish platform; InfoQ covered an earlier version on 22 Oct. According to the paper:
- AI agents increased lines of code by 44.0%, commits by 36.0% and pull requests opened by 35.7%.
- Jira issues resolved rose 13.7% with agents, a borderline-significant estimate, and the paper's estimates rule out an increase larger than 30.7%.
- The time from a pull request's submission to its approval went up 56.1%, and review comments per PR rose 38.6%.
The authors' explanation is that writing code is only part of the job. Engineers spend 30–40% of their time writing code; the rest is planning, review, testing and deployment. Speed up the writing and the other steps become the bottleneck.
So if PMs start producing merge requests on top of what AI agents already produce, the review queue is where it will hurt. That is the AI code review bottleneck in one sentence.
Why "PMs opening PRs" is the wrong unit
When a PM asks for a small product change, they rarely care about the code. They care that the button says the right thing, the empty state is useful, or the form stops asking for a field nobody needs.
Turning that into a PM-authored pull request adds work in the wrong places:
- The PM needs a dev setup, git, and enough context to not break things they cannot see.
- The engineer still has to review the code, and now also has to check whether it matches what the PM meant.
- The "is this what you meant?" loop happens inside code review, which is the slowest and most expensive place for it.
Gergely Orosz makes a related point in What is happening with code reviews?: automated tests are great at verifying business logic, but "they don't do a good job at verifying whether a UI looks and feels good." The small changes PMs ask for are mostly in that look-and-feel category. The best person to check them is the person who asked, looking at the running app.
The middle ground: ask on a live preview, ship through engineering
Here is the split we think works for small, visible changes:
- The PM asks, in plain words, on a live copy of the app. Not a mockup. The real app, running from the real code.
- A coding agent makes the edit. The PM sees the result on the same screen and keeps going ("a bit shorter", "the other button") until it is right.
- An engineer decides what ships. They read the conversation, check the diff in their own tools, and publish it the usual way. Or they discard it.
This separates asking from shipping, which is Gothelf's build-versus-ship idea applied to everyday product tweaks. The PM never needs commit access, an IDE, or a merge request. Engineering keeps every release decision.
It also changes what lands on the engineer's desk. Instead of a ticket plus three screenshots, or a PM's pull request of unknown intent, they get a change the requester has already seen working, with the full conversation attached. We cannot promise that makes review faster, and we have no data on it. But the intent question has been answered before the review starts.
Where to draw the line
The H&B question, "where do you draw the line?", deserves a direct answer. A reasonable starting line:
- Good for PM requests: copy, labels, layout, spacing, empty states, small UI fixes.
- Needs an engineer from the start: pricing logic, permissions, data models, anything touching auth or payments. A preview can look right and still be wrong.
- Not a chat request at all: big features. Those need design and scoping first.
Agree the list with your engineering lead before anyone starts. It is much easier than arguing about each request later. If you want a starting point, here is a policy template for what non-engineers can ask AI to change that you can paste into your wiki.
How Butterneck does this
Butterneck is one way to set up the middle ground. A developer connects a project folder on their own computer. The app gets a share link to a private live copy. A PM or other stakeholder opens the link and types the change in a chat beside the app. Or they label a Jira ticket butterneck and assign it, and a preview link is posted back on the ticket.
The developer's own coding agent (Cursor, Claude Code or Antigravity) edits the project on a developer's connected computer. The developer reviews and publishes the usual way. Butterneck never merges, never opens a pull request and never deploys.
A few honest details. .env files are on an ignore list the agent is told to stay out of. That is a guardrail, an instruction to the agent, not a hard block, so keep production secrets off that computer. Chat messages and preview traffic go through Butterneck's server, and the coding CLI sends code context to its provider as it does in normal use. More in how Butterneck runs an AI coding agent in a sandbox on your machine.
When it is not a fit
- You want AI to open pull requests or merge on its own. Butterneck deliberately does neither.
- There is no developer with a local project folder to connect.
- You are looking for a cloud IDE or a replacement for engineers.
For a product manager who wants to try Claude Code without setting up the repo, see Claude Code for product managers.
FAQ
Should product managers write code?
Some technical PMs do, and it can work. But most PMs do not need to write code to get small changes made. What they need is to describe the change where they see it, see the result on the real app, and hand it to an engineer who decides whether it ships. For the short version with a setup that works, see can product managers change the app without engineering?
Is it safe to let PMs ship code to production?
Teams trying it, like H&B, keep engineers reviewing both the plan and the merge request. If you want PMs involved without that overhead, let them ask on a live preview before the PR and keep the release with engineering.
Can product managers vibe code on an existing codebase?
Some teams do: a PM uses an AI coding tool on the real repository and opens a draft pull request for an engineer to review, usually for copy, layout and styling. Built In's guide recommends branch protection, required checks and a preview on every pull request before you try it, and most of these tools assume the PM can run the repository. Butterneck takes a different route: the PM asks on a live copy of the app, the developer's own coding agent makes the change on the developer's computer, and the PM checks it on the same preview. A developer then decides what ships. Butterneck never opens a pull request, merges or deploys. For the whole-team version, with one person deciding what ships, see vibe coding for teams.
Should a product manager review the AI-generated code?
Not line by line. The PM is the right person to check the result: does the button say the right thing, does the page look right, is it what they meant. So they check it on the running app, where they asked for it. A developer then reads the diff in their own tools and decides whether it ships. With Butterneck the PM checks the change on a live copy of the app and keeps asking until it is right; the developer reviews the code and publishes it the usual way, or discards it. Butterneck never opens a pull request, merges or deploys.
Does AI make code review the bottleneck?
The Harvard study suggests it can: with AI agents, pull requests opened went up 35.7%, while the time from a pull request's submission to its approval rose 56.1%. Adding PM-authored PRs to that queue makes it bigger. Nash, whose in-house agent opens pull requests for support, customer-success and operations staff, found the same thing once "anyone can ship": "the bottleneck moves to review, particularly plan review" (Nash, June 2026). Over 700 of its agent's pull requests have merged, and 97% of what it merges carries a human co-author who signed off on it. More on how Nash and three other companies split the work: who lets non-engineers ship.
Does Butterneck open pull requests for PMs?
No. Butterneck never opens a pull request, never merges and never deploys. The developer reviews the change and publishes it the usual way.
Try it
Book a 30-minute demo and bring a small change your PMs have been waiting on. Or check pricing: Starter is free for one developer and one requester, and Pro is $19 per person per month. A workspace owner on Starter can also try Pro free for one month. Learn more at butterneck.com.
Correction (27 Oct 2026): an earlier version misstated two figures from the study (Jira issues resolved and comments per PR); they now match the paper.
Update (31 Oct 2026): the authors revised the paper on 28 Oct 2026. The figures above follow that version; an earlier version reported 718 firms, 23% more pull requests and 49% longer review time.
Top comments (0)