Case study 03 · Agentic delivery
Delivery was constrained by handoffs and context loss between phases. I built 5 PM agents (Lisa for discovery, Bart for prototyping, Marge for PRD, Prince for acceptance testing, Homer for orchestration) that wrap Ralph, an open-source autonomous coding agent that handles implementation. The pipeline runs review-gated: agents do the artifact work; I make the product calls.
Product delivery follows a predictable loop - discovery, design, implementation, testing - but it's slowed by context switching across tools and artifacts, handoff latency between phases, and manual verification and rework. Even straightforward features could take days from idea to merged PR. This pipeline is how I continue to accelerate the same problem I've been solving since day one - just at a higher leverage point.
Five named PM agents, each owning one phase of delivery, running in sequence with clear human checkpoints so I stay in control of product judgment. Code lives in eshandeane/delivery-agents on GitHub.
Autonomous research agent. Searches Slack, Gmail, meeting transcripts, the web, and the codebase for context. Frames the problem, runs JTBD analysis, weighs solution tiers with a recommendation, and produces a structured discovery doc with napkin-sketch wireframes to make options concrete. Improves across runs via topic-scoped learnings written to a per-project memory file.
UI/UX prototyping agent that converts the approved discovery into prototypes built with real components from the design system, in a dedicated git worktree. Runs a loop of up to 15 iterations. Each iteration is a fresh Claude session that picks the next incomplete design task, then walks through build, review, and fix phases. The review phase scores 5 dimensions (visual clarity, interaction, consistency, accessibility, responsiveness) and requires a concrete browser action before each score is assigned. Cross-iteration memory lives in a learnings file so what Bart learned on the last task carries into the next.
PRD writing agent. Turns the reviewed prototype and decisions into a PRD broken into user stories with explicit acceptance criteria (the contract the build and test phases run against). Drafts the PRD, then pressure-tests it through a 7-perspective review panel: engineering, design, exec, legal, UXR, skeptic, customer voice. Resolves must-fix issues across up to 2 revision cycles before shipping. Suggestions get deferred to a section at the bottom of the PRD.
Ralph isn't one of the 5 agents I built. It's the open-source autonomous coding agent that handles implementation: reads the PRD's user stories, implements them, runs checks, commits, and opens a PR. My contribution at this step is the PRD-to-prd.json converter that feeds Ralph and the orchestration around it, so it builds the right thing.
Reads the PRD's acceptance criteria, spins up a Docker test DB, drives the browser through every criterion via Playwright, and outputs a structured pass/fail report with screenshots and a draft product announcement. On a failed criterion, enters an auto-fix loop: read the failure, attempt a fix, re-run the criterion, re-evaluate. Repeats until pass or flags the criterion for human review.
The orchestrator agent. Runs unattended on a launchd schedule (3 times a day) and scans Jira tickets in Roadmap and Design status. For each Roadmap ticket, Homer searches Circleback, Slack, and Gmail for real signal on the problem; if three criteria pass (clear pain, named user, real signal), Homer triggers Lisa. For each Design ticket, Homer looks for an attached design brief and triggers Bart in worktree mode if found. Homer never transitions a Jira ticket status (that's always the PM's call); the comment thread Homer posts on each ticket is the audit trail.
Homer scans Jira and triggers Lisa on a ticket with real signal. Lisa produces a discovery doc; I review and decide on a solution. Bart produces prototypes against the chosen direction; I review and approve the design. Marge drafts the PRD and runs it through her 7-perspective review panel; I read the final PRD. Ralph implements against the PRD and opens a PR. Prince validates against acceptance criteria and reports pass/fail. My role stays on product judgment and tradeoffs at each gate. The agents handle execution.
Open source: eshandeane/delivery-agents on GitHub.
| What I built | Output |
|---|---|
| Orchestration agents (discovery, prototyping, PRD, testing) | Feed validated context to the coding engine at every stage |
| Review-gated workflow | PM judgment held at each gate, PRs validated against acceptance criteria |
| Output (13 weeks) | 25 features across 27 PRs |
The point of the pipeline isn't volume - it's that every PR lands validated against explicit acceptance criteria, with product judgment held at the review gate. The autonomous coding engine handles execution; the orchestration I built keeps it pointed at the right thing.