This page covers the process behind the toolchain: the problem that forced a rebuild, what got built, which tools did the work, how instructions were structured, what got checked in code, how traceability was enforced end to end, where a human stayed in the loop, and what the process taught. The PetHealth case study shows the workflow running; this page covers how it got built.
Eight separate AI-assisted tools spanning the product-delivery lifecycle: persona research, journey mapping, feature intake, business-case generation, prioritization, requirements docs, backlog building, and batch planning. Each one worked in isolation. Tracing the actual data flow between them told a different story.
Eight cards sat on the tools index page, each one claiming to hand its output to the next. The prioritization tool wrote no output another tool could use; it only exported a static file. The backlog tool downstream re-implemented its own prioritization math from scratch, so two independent scoring implementations could silently disagree. Persona data had to be manually copy-pasted into the journey-mapping tool. Epic-level and feature-level planning were conflated in the shared schema, so prioritization decisions and delivery-team sizing decisions were happening on the same object when they needed to be separable.
Behind the "automated" label, the handoffs were manual copy-paste.
A restructured, nine-step workflow, deployed live: Persona → Journey Mapping → Initiative Intake → Business Cases → Epic Prioritizer → Roadmap & Milestones → Business Documents (the BRD) → Backlog Builder → Build Planner, ending in a CSV file for Jira's bulk import. Each step's output became the next step's input, passed along inside the browser.
The demo runs an insurance-claims initiative through the whole chain with both a front-stage persona and a backstage persona, deliberately, so the workflow has to handle customer-facing and infrastructure work correctly. That's where the original tools broke down: backstage work kept getting scoped as if it were customer-facing.
Nothing in the chain runs on free-text handoffs. Every stage has a typed input/output contract defined once in a shared package, and the model fills in that fixed schema.
Two instruction patterns did the most work. Cite only what's present: every generative step references evidence by a [REF] id and may only use ids included in its input; anything it lacks evidence for is marked ASSUMED. Keep independently-varying concepts decoupled: an early version conflated "is this epic customer-facing or infrastructure" with "does its business case rest on a customer metric or an engineering one." Two independent questions were collapsed into one field, which produced the wrong framing downstream. Splitting them into two fields, classified independently, was verified with a controlled test: two epics with identical infrastructure classification produced correctly divergent business-case framing.
Two tiers. First, a second AI pass on complex phases, framed as adversarial review, hunting for bugs. Second, and more important: a person tested every phase by entering realistic inputs, separate from the fixture data used for automated checks.
Scripted checks confirmed the code paths ran, but hand-authored test fixtures were too clean to surface these bugs.
Skip the human pass on a step with pasted or free-form input, and that's where bugs hide.
Recompute it in code afterward, every time, even after the model gets it right once.
A system that marks content ASSUMED or refuses below a threshold is more trustworthy than one that always sounds confident.
Tools that each work on their own were the gap that caused the original failure and started this rebuild.
Folding two real distinctions into one field for simplicity produces silently wrong downstream framing that's hard to trace back to its cause.
This page is the process behind the workflow. To see it run on one fictional initiative, walk the captured run. For how it's built (data contracts, code checks, and API key handling), read the technical notes.