// case study — ai-augmented product management
How I run a multi-person product scope solo
I was drowning in overtime covering four product areas alone. Instead of working more hours, I built an operating model: a coordinated team of specialist AI agents with contracts, quality gates, and one human in charge.
The problem
My scope was the workload of a multi-person product team: several extremely complex products, each demanding detailed specifications with rich user-interface walkthroughs to keep high-performing development teams continuously fed; ongoing market research; a living product roadmap; executive-level presentations; contract reviews. All of it owned by one person — me.
The math didn't work. I was covering it with extreme amounts of overtime, and overtime doesn't scale. Worse, being spread that thin meant quality was living on borrowed time: every hour spent writing a spec was an hour not spent validating one.
Why “just use AI” wasn't the answer
A single general-purpose AI assistant helps with volume, but it fails in a specific, predictable way: it has no boundaries. Ask it for requirements and it will happily pick your database. Ask it for a UX flow and it will rewrite your business rules along the way. Output goes up; trust goes down — and untrusted output just moves the bottleneck to review, which was exactly the hour I didn't have.
The insight was that my problem wasn't a writing problem, it was an organizationalproblem. What I was missing wasn't a faster pen — it was a team. So I designed one.
The problem wasn't a faster pen.
It was a missing team.
The design: an org chart of specialists
I built a multi-agent system modeled on how a well-run product organization actually works: one coordinator that only routes work, and eight specialist agents — Product Manager, Business Analyst, Project Manager, UX Expert, Solution Architect, Development, QA, and Technical Writer — each owning exactly one artifact type.
Every handoff carries an objective, constraints, and acceptance criteria — never instructions on how. The receiving agent is the expert in its domain and rejects anything that crosses that line.
Every deliverable is independently validated on receipt against four checks — completeness, consistency, ownership, authority. Verification is mandatory at every handoff, not optional.
No agent ever edits another agent's work. QA files defects; it doesn't fix code. Ownership never changes hands.
Iteration caps and criteria-bound acceptance keep review loops from ping-ponging forever, and a named human — me — is the circuit-breaker for anything irreversible or high-risk.
One boundary matters more than all the others: the agents don't decide what to build. Customer judgment, prioritization calls, and scope trade-offs stay with me — the PM agent drafts briefs and enforces scope discipline, but product direction is a human call. The agents produce; I direct, judge, and own the results.
Right-sizing the intelligence
One deliberate design decision that pays for itself daily: each agent runs on the smallest model sufficient to do its job at a high level — and nothing more. A routing coordinator doesn't need frontier-model reasoning; a solution architect weighing non-functional trade-offs does. Matching model capability to role keeps costs proportionate, responses fast, and — counterintuitively — quality up, because an over-powered model given a narrow job is exactly the one most tempted to overreach its lane.
The results
The overtime is largely gone. In its place: significantly higher output and higher quality — detailed specs with UI walkthroughs that keep development teams continuously supplied, current market research, an actively maintained roadmap, and executive presentations, all produced at a pace no single unassisted PM could sustain. I now carry what is normally a two-to-three-person product scope as one person, without the burnout math that used to make it possible only on paper.
What I learned
The biggest quality gains came not from better models but from scoped authority — agents that know what they're not allowed to decide.
Generation is cheap; trust is expensive. Building independent validation into every handoff is what turned raw output into work I could put my name on.
Left alone, agents will politely reject each other's work forever. Iteration caps, criteria-bound acceptance, and a human escalation endpoint aren't nice-to-haves — they're what makes the system converge.
Some guarantees are real mechanisms (scoped tool access, automated gates); others are conventions held by well-written charters. Knowing which is which is the difference between a demo and an operating model.
The roadmap: treating the system like a product
The operating model isn't finished — and I manage it the way I'd manage any product: with an honest assessment of its gaps and a prioritized roadmap. Currently on it:
The state layer already tracks first-pass yield, rework rate, and cycle time per work item. Next is baselining and trending them — so iteration caps get tuned from data, and the system's ROI is provable rather than felt.
Rules held by well-written charters should graduate to rules held by the platform: write-scoping and pre-write hooks on every agent, and schema validation on every handoff contract so a malformed handoff is rejected by a script, not by judgment.
Lifecycle state moves from free-form markdown to structured data updated through a small CLI — one bad edit shouldn't be able to drift the whole orchestration.
A charter edit is an untested deploy. A set of golden work items gets replayed after any charter or steering change to catch behavioral drift before it reaches real work.
The pipeline currently ends at documentation. An outcome-review step — did the success metrics actually hit? — will feed results back into the roadmap, so the system verifies not just built right but worth building.
Right-sizing decays as models improve and cheapen. Tracking cost-per-artifact per agent puts model assignments on a review cadence instead of leaving them frozen at whatever was optimal on day one.
Want the full system? The complete operating model — agent charters, the handoff contract, the four validation checks, loop controls, and a step-by-step build guide — is available as a downloadable PDF.
download the guide (pdf) ↗