lordmuffin · October 17, 2025 20:28
diff --git a/gistfile1.txt b/gistfile1.txt
 Most teams use AI for code generation. We use it to force product discipline.

 **The Problem:**
 Vague epics → ambiguous features → confusing stories → engineering waste.

 When a PM says "reduce cart abandonment" without metrics, acceptance criteria, or clear success measures, engineers spend 2 weeks building the wrong thing. Backlog refinement becomes a bottleneck.

 **The Solution:**
 Structured prompts to AI agents that enforce rigor before code is written.

 Instead of hoping a PM nails the specification, we give Copilot agents (or Claude Code Agents, or Gemini Gems) explicit templates:

 ✓ **Epic Agent**: Turns business goals into structured epics with:
  - Business value in *metrics*, not feels ("65% cart abandonment → target 42% completion")
  - 4-7 distinct features that can ship independently  
  - Success metrics that measure *outcomes*, not outputs
  - Explicit risks, constraints, and what's OUT of scope

 ✓ **Feature Agent**: Breaks epics into shippable features with:
  - User story format (As a X, I want Y, so that Z)
  - Testable acceptance criteria (Given/When/Then format)
  - Design links + technical considerations
  - Clear success metrics (not "customers are happy" but "30%+ click rate")

 ✓ **Backlog Item Agent**: Creates sprint-sized stories with:
  - Definition of Ready checklist (before eng starts)
  - Definition of Done checklist (before shipped)
  - Clear dependencies and effort estimates
  - Acceptance criteria QA can't misinterpret

 **Real Example:**

 PM Input: "We need to reduce cart abandonment. Show customers delivery dates."

 Epic Agent Generated:
 ```
 Epic: Reduce cart abandonment through transparent delivery time visibility

 Business Value: 65% abandonment + competitor shows dates → 8-12% improvement if we do too
  Saves ~$2M/quarter in lost revenue

 Scope: Delivery date API, cart display, shipping method selector, A/B test
 Success Metrics: 42%+ checkout completion (vs 35%), 40%+ users select paid express

 Timeline: Q1 (3-4 sprints) | Risks: Carrier API latency | Out of Scope: International
 ```

 Feature Agent Generated (for first feature):
 ```
 Feature: Display estimated delivery date in cart review

 Acceptance Criteria:
 AC1: Date updates when shipping method changes (no reload, <500ms)
 AC2: Show date in friendly format ("Arrives by Friday, March 5")
 AC3: Fallback if carrier API down ("Arrives in 3-5 business days")
 AC4: Mobile responsive (>14px font), accessible to screen readers

 Success Metrics: 75% reach rate (customers see the date)
 ```

 Backlog Items Generated (sprint-sized stories):
 ```
 Story 1 (Backend): Build /shipping/estimate API endpoint [M - 3-5 days]
 Story 2 (Frontend): Display delivery date on cart page [M - 3-5 days]
 Story 3 (QA): Test edge cases + performance [S - 1-2 days]
 ```

 **The Real Win:**
 The PM still makes all decisions. But now:
 - Engineers get unambiguous requirements, not guesses
 - QA has testable criteria, not vague expectations
 - Stakeholders see metrics upfront, not surprises after launch
 - The backlog is disciplined enough that stories fit in sprints

 The agent doesn't replace the PM. It enforces the discipline that good PMs do anyway—just faster, consistently, and at scale.

 **For your team:**
 - What's your biggest backlog bottleneck? Vague epics? Incomplete features? Ambiguous AC?
 - Where could structured prompts save your team 5+ hours per week?

 I'm sharing the actual agent prompts we use—if you want to see the full templates (Epic, Feature, Backlog Item agents with examples), DM me or comment below.

 #ProductManagement #AI #Agents #Backlog #ProductStrategy #Copilot
	Most teams use AI for code generation. We use it to force product discipline.

	The Problem:
	Vague epics → ambiguous features → confusing stories → engineering waste.

	When a PM says "reduce cart abandonment" without metrics, acceptance criteria, or clear success measures, engineers spend 2 weeks building the wrong thing. Backlog refinement becomes a bottleneck.

	The Solution:
	Structured prompts to AI agents that enforce rigor before code is written.

	Instead of hoping a PM nails the specification, we give Copilot agents (or Claude Code Agents, or Gemini Gems) explicit templates:

	✓ Epic Agent: Turns business goals into structured epics with:
	- Business value in metrics, not feels ("65% cart abandonment → target 42% completion")
	- 4-7 distinct features that can ship independently
	- Success metrics that measure outcomes, not outputs
	- Explicit risks, constraints, and what's OUT of scope

	✓ Feature Agent: Breaks epics into shippable features with:
	- User story format (As a X, I want Y, so that Z)
	- Testable acceptance criteria (Given/When/Then format)
	- Design links + technical considerations
	- Clear success metrics (not "customers are happy" but "30%+ click rate")

	✓ Backlog Item Agent: Creates sprint-sized stories with:
	- Definition of Ready checklist (before eng starts)
	- Definition of Done checklist (before shipped)
	- Clear dependencies and effort estimates
	- Acceptance criteria QA can't misinterpret

	Real Example:

	PM Input: "We need to reduce cart abandonment. Show customers delivery dates."

	Epic Agent Generated:
	```
	Epic: Reduce cart abandonment through transparent delivery time visibility

	Business Value: 65% abandonment + competitor shows dates → 8-12% improvement if we do too
	Saves ~$2M/quarter in lost revenue

	Scope: Delivery date API, cart display, shipping method selector, A/B test
	Success Metrics: 42%+ checkout completion (vs 35%), 40%+ users select paid express

	Timeline: Q1 (3-4 sprints) \| Risks: Carrier API latency \| Out of Scope: International
	```

	Feature Agent Generated (for first feature):
	```
	Feature: Display estimated delivery date in cart review

	Acceptance Criteria:
	AC1: Date updates when shipping method changes (no reload, <500ms)
	AC2: Show date in friendly format ("Arrives by Friday, March 5")
	AC3: Fallback if carrier API down ("Arrives in 3-5 business days")
	AC4: Mobile responsive (>14px font), accessible to screen readers

	Success Metrics: 75% reach rate (customers see the date)
	```

	Backlog Items Generated (sprint-sized stories):
	```
	Story 1 (Backend): Build /shipping/estimate API endpoint [M - 3-5 days]
	Story 2 (Frontend): Display delivery date on cart page [M - 3-5 days]
	Story 3 (QA): Test edge cases + performance [S - 1-2 days]
	```

	The Real Win:
	The PM still makes all decisions. But now:
	- Engineers get unambiguous requirements, not guesses
	- QA has testable criteria, not vague expectations
	- Stakeholders see metrics upfront, not surprises after launch
	- The backlog is disciplined enough that stories fit in sprints

	The agent doesn't replace the PM. It enforces the discipline that good PMs do anyway—just faster, consistently, and at scale.

	For your team:
	- What's your biggest backlog bottleneck? Vague epics? Incomplete features? Ambiguous AC?
	- Where could structured prompts save your team 5+ hours per week?

	I'm sharing the actual agent prompts we use—if you want to see the full templates (Epic, Feature, Backlog Item agents with examples), DM me or comment below.

	#ProductManagement #AI #Agents #Backlog #ProductStrategy #Copilot
No results found