Amplitude's Wave Agent Turns Product Managers Into Ship Captains
Amplitude's internal agent Wave decides what to build, hands the work to coding agents, and checks whether it worked — compressing a cycle that once took weeks into one or two days.
Independent UpShaqo analysis built from fresh, attributed sources. We explain the impact instead of repeating the announcement.
Read for leverage: focus on the workflow change, the customer problem, and the next action—not only the product announcement.
At most software companies, the person who decides what gets built next spends their week in meetings, dashboards, and Slack threads, trying to triangulate which fix matters most. At Amplitude, that job increasingly belongs to an agent. It's called Wave, and according to OpenAI's account of the deployment, it identifies what to build, hands the work to coding agents, and then measures whether the change actually helped — on a cycle that runs in a day or two rather than a sprint or a quarter.
That's a small set of facts from a short customer story, but the shape of the workflow is worth taking seriously, because it describes a role reversal that a lot of product organizations are quietly edging toward: the agent isn't assisting the product manager anymore. It's doing the product manager's core job — prioritization, execution handoff, and impact measurement — and the human is reviewing its work rather than originating it.
The Agent With a Product Manager's Job Title
Wave's job, as described, has three parts: figure out what to build, get it shipped, and check the results. That's the same loop every product management framework has formalized for a decade — discover, deliver, validate — except Wave appears to run all three stages itself, using OpenAI models as its reasoning layer and coding agents as its hands. The human product team's role shifts from doing the loop to supervising it.
This matters because the bottleneck in most product organizations was never a shortage of ideas. It was the friction between having an idea, getting engineering time allocated, and waiting long enough to know if the idea worked. Wave appears to be an attempt to collapse that friction into something closer to a single, continuously running process rather than three separate human-gated steps.
The Old Loop: Backlog, Debate, Backlog Again
UpShaqo's analysis of the before-state, inferred from how product teams at comparable B2B SaaS companies typically operate, looks something like this: a product manager notices a signal in usage data, writes it up, brings it to a prioritization meeting, and if it survives the debate, it enters an engineering backlog where it competes with dozens of other requests. Weeks pass before a developer picks it up. More weeks pass before it ships. Then someone has to remember to check if it worked, often after the context has gone cold.
The cost of that loop isn't just slowness — it's attrition of good ideas. Signals get stale, priorities shift, and by the time a fix ships, the team has often moved on to the next fire. Measurement becomes an afterthought because nobody owns it once the ticket is closed.
The New Loop: Identify, Build, Measure, Repeat
Amplitude's claimed outcome is a one-to-two-day cycle from identification to shipped, measured change. That's not a marginal speedup over a multi-week backlog process — it's a different category of operation. A one-to-two-day loop means a team can run the identify-build-measure cycle dozens of times in the span that used to produce a single release.
The practical consequence, worth spelling out because it's easy to skim past: at that cadence, product work stops looking like a project plan and starts looking like a continuously tuned system. Each cycle's measurement becomes the input for the next cycle's identification step, which is exactly the compounding loop that makes agentic systems valuable over static automation — the output of one run becomes the training signal for the next.
What Wave Actually Automates
Based on the source material, Wave performs three distinct functions rather than one generic "AI coding" task:
- Identification — surfacing what to build, presumably by reasoning over product usage data, the kind of information Amplitude's core analytics platform is built to collect.
- Delivery — handing the specified change to coding agents that implement it, rather than routing it to a human engineer's backlog.
- Measurement — closing the loop by assessing whether the shipped change produced the intended effect.
The notable design choice is that measurement isn't bolted on afterward — it's built into the same agent that proposed the change in the first place. That's a meaningful departure from how most teams operate today, where the person who decides what to build and the person who eventually checks if it worked are often not the same person, and the check frequently doesn't happen at all.
Running This Inside Your Own Team
The source material doesn't disclose Amplitude's internal build sequence, so the following is UpShaqo's inferred framework for operators trying to replicate the pattern, not a confirmed account of what Amplitude did:
- Instrument before you automate. An identification agent is only as good as the usage data it reasons over. Teams without clean product analytics should expect this step to take longer than the agent-building itself.
- Separate the proposal step from the execution step. Let one agent generate and rank candidate changes before handing anything to a coding agent — mixing judgment and execution in a single pass makes failures harder to diagnose.
- Give the coding agent a narrow, well-scoped task. Agentic coding tools perform best on bounded changes, not open-ended feature builds — which likely explains why Amplitude's cycle is measured in one to two days rather than weeks.
- Close the loop automatically. Build the measurement step into the same system, with a defined metric and a defined window, rather than relying on a human to remember to check back.
- Keep a human checkpoint before deployment, at least initially, since the cost of shipping a wrong change at this cadence compounds quickly if nobody is watching.
The Metrics That Decide If It's Working
For any team adopting this pattern, the honest success criteria aren't vanity metrics like "features shipped." They're:
- Cycle time from signal to shipped change — Amplitude's benchmark is one to two days; teams should track their own baseline before comparing.
- Hit rate on measured impact — what percentage of shipped changes actually move the metric they were meant to move, not just how many ship.
- Reversal rate — how often a change has to be rolled back, which is the clearest signal of whether the identification step is actually sound.
- Human review time per cycle — the point of the system is to compress effort, not just elapsed time, so review burden has to shrink too, not just move downstream.
Where the Risk Hides
The tradeoff with a system that ships in one to two days is that mistakes also ship in one to two days. A faster loop raises the stakes on the quality of the identification step, because there's less time for a human to catch a bad call before it's live. Teams considering this pattern should weigh the speed gain against the blast radius of an agent-originated change that turns out to be wrong — and should resist the temptation to remove human review entirely just because the system is fast enough to make that tempting.
Sources
OpenAI — "How Amplitude ships product improvements in 1–2 days with OpenAI"