Rob Dull AI Portfolio
AI-assisted Product Operations · Working prototypes

Product workflow prototypes
built to be inspected

This portfolio explores a practical question: can AI reduce the drafting and translation work between product discovery, prioritization, requirements, and delivery without obscuring where human judgment is still required? The primary prototype is a nine-step, single-user browser workflow. Each step produces a structured artifact that can be reviewed, edited, and passed to the next tool. Selected consistency checks are computed in code. The workflow ends with a Jira bulk-import CSV.

Document Flow ↗ Network Diagram ↗ Explore AI ProdOps ↗
Working proof of concept. This is not a customer deployment or a production Product Operations platform. It is a working prototype built to test workflow design, artifact continuity, deterministic guardrails, and the quality limits of AI-generated product documentation.
Scope: AI-assisted Product Management, not full Product Operations. Product Operations spans six practice areas. This toolchain works with three of them: Data Collection (customer and market evidence feeding the persona, journey, and intake tools), Feedback Management (support tickets, sales notes, and user requests synthesized into initiatives and business cases), and Roadmap Alignment (prioritizing initiatives by data, strategy, and capacity in the epic prioritizer and roadmap). It does not cover Release Operations (feature flags, beta testing, deployment communications), Enablement and Training (preparing sales, marketing, and support for launches), or Performance Analytics (measuring post-launch impact against KPIs). See the full PM vs. ProdOps breakdown ↗.
Evaluate the working example: follow one fictional initiative from customer context through a Jira-ready delivery plan in the end-to-end PetHealth case study. Understand the implementation: review the stack, data contracts, deterministic checks, and limitations in the technical notes. Join the Limited Evaluation Beta: test the prototype with a fictional, public, or sanitized initiative using the evaluation guide.
How the workflow operates: The nine tools share structured state in the browser. A practitioner initiates each step, reviews the draft, makes corrections where needed, and decides whether to continue. Some tools use multi-step model calls; others are primarily deterministic browser interfaces. The workflow does not autonomously choose its own objective, select tools, or operate enterprise systems.

Several tools can generate new content by calling the Claude API directly from your browser with a visitor-supplied key. Other tools are client-side. Every stage can be inspected without a key through a worked example or its non-generative interface, but generating new AI output requires a key in the tools that use the model. State is stored locally in the browser and can be downloaded as a run file. There are no user accounts, team workspaces, or server-side project records.

Review gates and where the workflow could extend: Most tools break their work into multiple steps, and each step is a human review point: the practitioner sees the draft before deciding whether it carries forward. Beyond that review, each step is also a natural extension point for supplying additional context, currently by pasting it in directly.

In the target architecture, that extension point could be served by knowledge management agents: services that pull relevant material from connected systems, contextualize it against the step at hand, and prioritize what's worth surfacing to the reviewer before a draft is generated. That layer is designed, not built. Today, a step only knows what the practitioner supplies to it.

One connected workflow
01 — DISCOVER
Persona generator
Open ↗
02 — MAP
Journey map
Open ↗
03 — INTAKE
Initiative intake
Open ↗
04 — PITCH
Business cases
Open ↗
05 — RANK
Epic prioritizer
Open ↗
06 — SCHEDULE
Roadmap & milestones
Open ↗
07 — SPEC
Business documents
Open ↗
08 — PLAN
Backlog builder
Open ↗
09 — DELIVER
Sprint planner
Open ↗
Each tool hands its output to the next
See the full document flow: BRD, Roadmap, Backlog, Jira export ↗
Enterprise User Research
JTBD + Enterprise
Persona Generator
Working prototype

Takes a rough user description and produces a detailed enterprise persona with Jobs to Be Done statement, org context, tech comfort, key interactions, and relationship friction, detailed enough to anchor a journey map.

Produces · passes forward · status · human responsibility
Produces: Persona record. Passes forward: Persona context for journey mapping. Status: Working prototype · Client-side. Human responsibility: Confirm that the persona reflects evidence rather than a convenient composite.
Jobs to Be Done Persona card Key interactions Relationship friction Info preference Copy to export
Open tool ↗
PERSONA CARD Marcus Chen Software Engineer · PetHealth Member "I just want to know it's working." Until he needs it. JOBS TO BE DONE When I want to So I can TECH COMFORT Mobile App Web Portal Phone / Chat
What it produces
  • Full persona card: name, title, department, tenure, reports-to, location
  • First-person quote, bio, wants and needs, frustrations
  • Technology comfort ratings across five relevant platforms
  • Information preference: how this person consumes data and why it matters for design
  • Key interactions table with color-coded friction, dependency, and reporting badges
  • Organizational impact of unmet job: three quantified consequences
  • Copy-to-clipboard export formatted for Miro, Figma, or product briefs
Customer Experience
Customer
Journey Map Builder
Working prototype

A journey map is only useful if it reflects what actually happens, not what teams assume. This tool provides an editable, stage-by-stage canvas for mapping customer actions, goals, touchpoints, emotions, and organizational responses, with a draggable sentiment curve and one-click AI export for analysis.

Produces · passes forward · status · human responsibility
Produces: Journey map and structured opportunity seeds. Passes forward: Candidate pain clusters for initiative framing. Status: Working prototype · Client-side. Human responsibility: Separate observed evidence from team assumptions.
Editable stages User sentiment curve Touchpoints Pain points Business goals Export for AI
Open tool ↗
PRE-ENROLL ACCOUNT MGMT CLAIMS RENEWAL ACTIVITIES TOUCHPOINTS SENTIMENT KPIs 📱 🌐 📋 ✉️
What it produces
  • Draggable sentiment curve that captures emotional highs and lows across the journey
  • Row-level data for activities, goals, touchpoints, pain points, and business OKRs
  • Toggleable rows: show only the layers relevant to your current audience
  • Add and remove stages dynamically without losing other row data
  • One-click plain-text export structured for pasting directly into an AI prompt
  • JSON export for version control or integration into other tools
Agentic PDLC Demo
Initiative
Intake
Working prototype

Four sequential AI calls that weigh one Initiative against competing initiatives with strategy, budget, and demand evidence, then decompose it into front-stage Business Epics and backstage Architecture Epics, exploring both together, splitting only where an epic genuinely needs runway before front-stage work can start. Each epic gets its riskiest Demand/Feasibility/Viability assumptions and a benefits-realization plan naming the measurement instrumentation that must be built.

Produces · passes forward · status · human responsibility
Produces: Epic set, assumption map, and measurement-enabler proposals. Passes forward: Candidate epics for business-case development. Status: Working prototype · Multi-step AI chain · Fixture-backed evidence available. Human responsibility: Correct invented context, reject generic epics, and validate every assumption and proposed metric.
Portfolio tradeoff Business + Architecture epics D/F/V assumptions Measurement enablers Evidence citations
Open tool ↗
01 TRADEOFF 02 EPICS 03 D/F/V 04 BENEFITS INITIATIVE TRADEOFF FUNDED EPIC-03 KIND / CASE BUSINESS DEMAND / FEASIBILITY / VIABILITY DMD FEAS VIAB BENEFITS REALIZATION ≥60% engaged 3 MEASUREMENT ENABLERS
What it produces
  • A framed Initiative weighed against competing initiatives with cited strategy, budget, and demand evidence
  • 3–6 epics in two kinds, front-stage Business and backstage Architecture, each with a problem statement and JTBD
  • Per-epic Demand, Feasibility, and Viability assumptions: the risk surface the Business Case builds on
  • A benefits-realization plan per epic: KPIs, baseline, and the measurement enablers that must be built
  • Framing note explaining which enablers earned a separate architecture epic, and why
Agentic PDLC Demo
Business
Cases
Working prototype

One executive-ready pitch per epic, Business or Architecture, grounded in financial and demand evidence, with a rough order-of-magnitude effort estimate for the Epic Prioritizer's WSJF/RICE job size. Pitch framing follows the epic's caseType, not its kind: a backstage Architecture epic with a customer-facing case (fraud analytics protecting member trust) still gets the customer-value narrative, not a generic technical writeup.

Produces · passes forward · status · human responsibility
Produces: Business-case record per epic. Passes forward: Candidate records for prioritization. Status: Working prototype · AI-assisted. Human responsibility: Verify costs, benefits, effort, strategic claims, and the cost of inaction.
One case per epic caseType-driven framing Rough LOE effort Exec-summary seed Evidence citations Saved for prioritizer
Open tool ↗
EPIC BUSINESS CASE EPIC-03 EXECUTIVE PITCH 3.2x ROI 18 mo. payback PEOPLE IMPACT RISKS OF INACTION COST / BENEFIT
What it produces
  • Value and cost statements framed by the epic's caseType: technical or customer-facing
  • Rough order-of-magnitude effort (LOE), anchoring the prioritizer's job size in code
  • Strategic alignment statement tying the epic back to the initiative
  • An exec-summary seed that carries forward verbatim into the BRD
  • Evidence citations from fixture-backed financial and demand records
Agentic PDLC Demo
Epic
Prioritizer
Working prototype

Two sequential AI calls that rank every Business and Architecture epic in one pass, scored on BOTH the WSJF components and the RICE components at once, so the board toggles between methods instantly with no re-run. Architecture epics take their business value from what they unblock and typically dominate risk-reduction; the board recomputes every score in code and anchors job size to the epic's Business Case effort.

Produces · passes forward · status · human responsibility
Produces: Ranked epic set and a proposed funding line. Passes forward: Prioritization record for roadmap sequencing. Status: Working prototype · AI-assisted inputs · Deterministic calculations. Human responsibility: Validate the input values and own the weighting decision. A correctly calculated score is not automatically a defensible investment decision.
Evidence digest with quotes WSJF ⇄ RICE toggle Editable weights Architecture-epic economics Funding line Weight rationale citations
Open tool ↗
01 EVIDENCE DIGEST 02 WSJF + RICE RANKING BOARD — RECOMPUTED IN CODE RANK EPIC SIZE WSJF 1 Fraud & Leakage Analytics ARCHITECTURE 5 6.0 2 Auto-Adjudication Engine ARCHITECTURE 8 5.6 FUNDING LINE — TOP 3 3 Real-Time Claim Status BUSINESS 3 5.0 Raise RR|OE weight to 2: fraud analytics overtakes claim status for #1. WSJF — BV / TC / RR|OE RICE — REACH / IMPACT / CONF.
What it produces
  • Evidence digest: value claims quoted verbatim with confidence marks, urgency, risk retired, and gaps
  • Both WSJF and RICE components scored in one pass: the board toggles methods with no re-run
  • Architecture-epic economics: scored on what they unblock, not zero-by-default
  • Editable weights with a one-click risk-weighted preset, citing leadership's rationale
  • A real funding line; funded epics flow to Roadmap & Milestones
Agentic PDLC Demo
Roadmap
& Milestones
Working prototype

One AI call that sequences every prioritized epic, funded this increment or profitable and awaiting capacity, into a milestone plan spanning up to 18 months. Funded epics fill the earliest release windows; the rest follow in rank order as capacity frees. The dependency list stays deliberately light: a named approval or a genuine architecture-epic runway prerequisite, nothing more.

Produces · passes forward · status · human responsibility
Produces: Roadmap and milestone proposal. Passes forward: Funded epic and release context for documentation. Status: Working prototype. Human responsibility: Validate capacity, dependencies, organizational commitments, and release assumptions.
Up to 18-month horizon Rank-ordered sequencing Light dependency list Release-on-demand stance .md export
Open tool ↗
ROADMAP & MILESTONES 18-MO PLAN Q3 '26 Q4 '26 Q1 '27 Q2 '27 MS-01 · Runway EPIC-01 funded MS-02 · Fraud live EPIC-05 funded MS-03 · Claim status transparency live EPIC-03 deps: EPIC-01 runway, security review sign-off
What it produces
  • A milestone plan sequencing every funded and near-funded epic across up to 18 months
  • Funded epics fill the earliest release windows; the rest follow in rank order
  • A deliberately light dependency list: named approvals and genuine runway prerequisites only
  • A rollout stance note assuming continuous deployment and release on demand
  • Markdown export; the saved roadmap gates which epics get a BRD next
Agentic PDLC Demo
Business
Documents
Working prototype

Two sequential AI calls that write a standard-template Business Requirements Document for ONE funded epic: never a feature, story, or technical breakdown. A requirements core (scope boundary, prioritized business requirements with measurement enablers flagged, high-level NFRs each tied to the epic's Feasibility assumption) followed by the executive package: summary, objectives, stakeholders, constraints, cost-benefit, and sign-off.

Produces · passes forward · status · human responsibility
Produces: BRD. Passes forward: Structured requirements for backlog development. Status: Working prototype · Two-step AI chain · Funding gate enforced in code. Human responsibility: Remove unsupported precision, validate NFR thresholds, confirm stakeholders, and replace assumed financial claims with evidence.
Standard BRD template Measurement enablers High-level NFRs Stakeholder & sign-off tables Cost-benefit analysis .md download
Open tool ↗
01 REQUIREMENTS CORE 02 EXECUTIVE PACKAGE BUSINESS REQUIREMENTS BR-01 HIGH BR-02 HIGH BR-03 MED MEASUREMENT ENABLER BR-04 MED HIGH-LEVEL NFRS NFR-01 ↯ tied to the Feasibility assumption Executive Summary OBJECTIVES ≥60% engaged · ≤12% contacts Rank #3 · funded, 2026 Q4 Stakeholders & Sign-off APPROVER COST-BENEFIT · TOTAL COST · ROI
What it produces
  • Scope boundary and 5–9 business requirements with priority, criticality, and measurement-enabler flags
  • High-level NFRs, each tied to the epic's Feasibility assumption from Initiative Intake
  • Executive summary seeded from the Business Case, plus measurable objectives and KPI baselines
  • Stakeholder, constraint, and cost-benefit tables with total cost, expected ROI, and sign-off list
  • Refuses epics below the funding line: only documents what the Roadmap actually scheduled
Agentic PDLC Demo
Backlog
Builder
Working prototype

Five sequential AI calls that turn one funded epic's BRD into its full delivery-doc suite: MoSCoW'd Features with feature-level NFRs and refined sizing (stories inherit their feature's priority, never prioritized themselves), a Solution Outline with target-state architecture and simple user flows, a Security & UAT plan, and Developer/User documentation. Requirement coverage is computed in code, not generated.

Produces · passes forward · status · human responsibility
Produces: Extended backlog and supporting delivery documents. Passes forward: Stories, estimates, priorities, and dependency relationships. Status: Working prototype · Multi-step AI chain · Requirement-coverage check in code. Human responsibility: Confirm technical feasibility, testability, architectural fit, and whether apparent requirement “coverage” is substantively appropriate.
MoSCoW at the feature level Refined sizing + variance flag Solution outline + architecture Security & UAT plan Coverage computed, not generated .md download
Open tool ↗
01 FEATURES 02 STORIES 03 SOLUTION 04–05 DOCS FEATURES — MOSCOW FEAT-01 MUST L FEAT-02 MUST M FEAT-06 SHLD M MoSCoW lives here, never on stories; they inherit it. COVERAGE — COMPUTED ✓ 8 of 8 BRs covered Refined Σ vs. rough OK Sizing variance flagged, not fixed ST-04 · FEAT-01 · dependsOn ST-01 MUST 8 pts ✓ Given a member opens the status view, when it loads, then…
What it produces
  • 4–9 MoSCoW'd Features with feature-level NFRs and refined delivery sizing
  • 2–4 ordered stories per feature, BDD acceptance criteria, points, and dependsOn sequencing
  • Solution outline: summary, target-state architecture, and simple per-feature user flows
  • Security review guidelines/plan and a UAT approach for the org doc repository
  • Developer & user docs, computed BR coverage, and an effort-variance flag against WSJF sizing
Agentic PDLC Demo
Sprint Planner
& Jira Export
Working prototype

Two sequential AI calls that turn one epic's extended backlog into a delivery plan: MVP scope, a sprint-by-sprint allocation, baseline and worst-case estimates, and a RAID log. Sprint loads and dependsOn ordering are recomputed in code: an over-capacity sprint or a story landing no earlier than its dependency both raise a visible warning, wherever the plan is consumed. Finishes with a Jira bulk-import CSV.

Produces · status · human responsibility
Produces: Delivery-plan proposal, RAID log, and Jira CSV. Status: Working prototype · AI-assisted planning · Deterministic load and dependency checks. Human responsibility: Own the plan, validate team capacity, and inspect the CSV before importing it into a delivery system.
MVP scope Capacity + dependency guards Baseline vs worst-case dependsOn sequencing RAID log Jira bulk-import .csv
Open tool ↗
01 SPRINT PLAN 02 RAID LOG SPRINT-BY-SPRINT — LOAD IN CODE SPRINT 1 14/32 SPRINT 2 12/32 SPRINT 3 10/32 BASELINE 3 sprints WORST CASE 5 sprints RAID RISK ASSM ISSUE DEP Stage registry gates the chain MVP SCOPE ST-01 ST-02 ST-03 ST-04 ST-05 ST-06 ST-07 ST-08 ST-09 ST-10 ST-11
What it produces
  • MVP scope: the must-have stories for the first release, pulled from the Must-priority features
  • A sprint-by-sprint plan with goals, honoring points capacity and each story's dependsOn edges
  • Per-sprint load AND dependency order both recomputed in code, with visible violation warnings
  • Baseline and worst-case delivery estimates, with the drivers that widen the gap
  • A RAID log plus a Jira bulk-import CSV: Summary, Priority, Points, Sprint, and Blocks links
Strategy and Execution
Hoshin Kanri
+ V2MOM Alignment
Working prototype

Enter your V2MOM (vision, values, methods, and measures) and this tool cascades it directly into a Hoshin Kanri X-matrix. Values become annual objectives. Methods map exactly to activities. Measures drive key metrics. The matrix is color-coded by value group, correlation dots are interactive, and Claude can align and refine the whole thing on demand.

Off-chain prototype
Explores how a V2MOM can be represented as a Hoshin Kanri X-matrix. This is a standalone strategy-alignment tool, not a step in the nine-stage initiative workflow. Status: Working prototype.
V2MOM cascade X-matrix visualization Color-coded by value Interactive correlation dots AI alignment Vision alignment row
Open tool ↗
HOSHIN KANRI + V2MOM X-MATRIX VISION ALIGNMENT Redesign claim submission flow Proactive renewal outreach Launch in-app vet directory Member sentiment dashboard Priorities and Activities Annual Objectives Key Metrics Long-term Objectives A seamless, trustworthy member experience across every stage CO-OWNERS
What it produces
  • A full Hoshin Kanri X-matrix cascaded directly from your V2MOM: values to objectives, methods to activities, measures to KPIs
  • Color coding by value group flows across activity rows, objective columns, and KPI columns for instant visual correlation
  • Vision alignment row showing how directly each annual objective expresses the stated vision
  • Interactive dot cells: click to cycle through direct, complementary, and empty correlation states
  • AI cleanup and realignment that improves phrasing, adjusts correlations, and preserves your manual edits
  • Adjustable matrix dimensions: add or remove rows and columns for any zone on the fly
Organizational Health
Product Operations
Health Radar
In development

A structured self-assessment across the core dimensions of product operations delivery. Surfaces where teams are strong, where they are struggling, and what to prioritize first.

Off-chain prototype
Explores a structured self-assessment of Product Operations practices and delivery conditions. Status: In development.
Delivery health Radar visualization Prioritized recommendations Team assessment
PRODUCT OPS HEALTH RADAR IN DEVELOPMENT Discovery Delivery Metrics Tooling Collab Strategy TOP PRIORITIES Discovery Delivery Metrics Tooling Collab Strategy Focus: 2 areas flagged
What it will produce
  • Radar chart across eight product operations dimensions: discovery, delivery, metrics, tooling, and more
  • Scored self-assessment with dimension-level commentary
  • AI-generated interpretation of the pattern: what the shape of the radar means organizationally
  • Prioritized recommendation set ranked by impact and effort
  • Export for leadership review or team retrospective facilitation
What this portfolio demonstrates

It does not demonstrate customer adoption, production reliability, enterprise integration, security approval, or measured business outcomes.

Limited Evaluation Beta
I'm recruiting a small group of practitioners to test the working prototype.
The objective is not to prove that the system can replace professional judgment. It is to learn whether the workflow produces useful first drafts, where continuity survives the handoffs, where unsupported claims enter the chain, and which controls would be required before the approach could be used in a real organization. Use fictional, public, or sanitized information only.
Evaluate the prototype ↗
Side Projects
Built for fun, engineered with care.

Not everything here is a PM tool. This is what I build when the constraint is a friend group and a weekend, not a product roadmap.

Browser Game
500 Card Night
Live

500 is the card game I've played with the same group of friends since college. It's simpler than bridge, more interesting than euchre. The existing online versions are buggy, clumsily monetized, and don't follow our house rules. I've wanted to build my own since I was working in the Java games division at Nokia. That was twenty years ago. I finally built it in two days with Claude.

No accounts, no server, no database. Share a room code; play from anywhere. Four players, peer-to-peer, entirely in the browser.

Try it solo (no friends required)
Open the game in four separate browser tabs. Each tab joins the same room and plays as a different seat. It's how I test every change: the full four-player game running on one machine, no network required.
TypeScript React / Vite WebRTC / PeerJS Three-repo architecture No backend
Play the game ↗
500 Card Night lobby
500 Card Night play view 500 Card Night end of hand 500 Card Night bidding 500 Card Night bidding round 2