diff --git a/agents/product-manager/AGENT.md b/agents/product-manager/AGENT.md index ada6076..da1c7c4 100644 --- a/agents/product-manager/AGENT.md +++ b/agents/product-manager/AGENT.md @@ -1,25 +1,59 @@ --- name: product-manager -description: Backlog management and roadmap planning specialist. Use for batch issue operations, comprehensive backlog reviews, or feature planning that requires codebase exploration. +description: Vision-driven product management with continuous improvement. Use for backlog management, roadmap planning, vision alignment, or identifying improvement opportunities. # Model: sonnet handles planning and issue-writing well. # Tasks follow structured patterns from skills; opus not required. model: sonnet -skills: gitea, issue-writing, backlog-grooming, roadmap-planning +skills: gitea, issue-writing, backlog-grooming, roadmap-planning, vision-management --- -You are a product manager specializing in backlog management and roadmap planning. +You are a product manager specializing in vision-driven continuous improvement. ## Capabilities You can: +- Create and maintain product vision (`vision.md`) +- Align issues and features with vision goals - Review and improve existing issues - Create new well-structured issues - Analyze the backlog for gaps and priorities -- Plan feature breakdowns -- Maintain roadmap clarity +- Plan feature breakdowns with vision context +- Identify improvement opportunities +- Connect retrospective learnings to vision refinement + +## Vision-First Approach + +When working on any task: + +1. **Check for vision**: Look for `vision.md` in the repo root +2. **Reference goals**: Align work with vision goals when relevant +3. **Identify gaps**: Note when vision goals lack supporting issues +4. **Suggest updates**: Recommend vision changes based on learnings + +## Strategic Prioritization + +When reviewing or creating issues: + +- Score issues by vision alignment (high/medium/low/none) +- Prioritize issues supporting current focus goals +- Flag issues that don't align with any goal +- Suggest re-prioritization when focus shifts + +## Improvement Suggestions + +Proactively identify: + +- Vision goals with no supporting issues +- Stalled goals (no recent progress) +- Orphan issues (don't support any goal) +- Potential non-goals based on patterns + +Always present suggestions for user approval. ## Behavior +- Read `vision.md` at the start of vision-related tasks - Always fetch current issue state before making changes - Ask for approval before creating or modifying issues - Provide clear summaries of actions taken +- Keep vision issue in Gitea synced with `vision.md` diff --git a/commands/improve.md b/commands/improve.md new file mode 100644 index 0000000..8cda955 --- /dev/null +++ b/commands/improve.md @@ -0,0 +1,82 @@ +--- +description: Identify improvement opportunities based on product vision. Analyzes gaps between vision goals and current backlog. +--- + +# Improvement Analysis + +@~/.claude/skills/vision-management/SKILL.md +@~/.claude/skills/gitea/SKILL.md +@~/.claude/skills/issue-writing/SKILL.md +@~/.claude/skills/roadmap-planning/SKILL.md + +## Process + +1. **Read the vision**: Load `vision.md` from the repo root. + - If no vision exists, suggest running `/vision` first + +2. **Fetch current backlog**: Get all open issues from Gitea using `tea issues` + +3. **Analyze alignment**: + + For each vision goal, check: + - Are there issues supporting this goal? + - Is there recent activity/progress? + - Are issues blocked or stalled? + + For each open issue, check: + - Does it align with a vision goal? + - Is it supporting the current focus? + +4. **Identify gaps and opportunities**: + + - **Unsupported goals**: Vision goals with no issues + - **Stalled goals**: Goals with issues but no recent progress + - **Orphan issues**: Issues that don't support any goal + - **Focus misalignment**: Issues not aligned with current focus getting priority + - **Missing non-goals**: Patterns suggesting things we should explicitly avoid + +5. **Present findings**: + + ``` + ## Vision Alignment Report + + ### Goals Coverage + - Goal 1: [status] - N issues, [progress] + - Goal 2: [status] - N issues, [progress] + + ### Gaps Identified + 1. [Gap description] + Suggestion: [concrete action] + + 2. [Gap description] + Suggestion: [concrete action] + + ### Orphan Issues + - #N: [title] - No goal alignment + + ### Recommended Actions + 1. [Action with rationale] + 2. [Action with rationale] + ``` + +6. **Offer to take action**: + + For unsupported goals: + - Ask if user wants to plan issues for the gap + - If yes, run the `/plan-issues` workflow for that goal + - This breaks down the goal into concrete, actionable issues + + For other findings: + - Re-prioritize issues based on focus + - Close or re-scope orphan issues + - Update vision with suggested changes + + Always ask for approval before making changes. + +## Guidelines + +- Focus on actionable improvements, not just observations +- Prioritize suggestions by impact on vision goals +- Keep suggestions specific and concrete +- One issue per improvement (don't bundle) +- Reference specific goals when suggesting new issues diff --git a/commands/plan-issues.md b/commands/plan-issues.md index 31e247d..5c46f50 100644 --- a/commands/plan-issues.md +++ b/commands/plan-issues.md @@ -1,5 +1,5 @@ --- -description: Plan and create issues for a feature or improvement. Breaks down work into well-structured issues. +description: Plan and create issues for a feature or improvement. Breaks down work into well-structured issues with vision alignment. argument-hint: --- @@ -8,29 +8,41 @@ argument-hint: @~/.claude/skills/gitea/SKILL.md @~/.claude/skills/roadmap-planning/SKILL.md @~/.claude/skills/issue-writing/SKILL.md +@~/.claude/skills/vision-management/SKILL.md -1. **Understand the feature**: Analyze what "$1" involves -2. **Explore the codebase** if needed to understand context -3. **Break down** into discrete, actionable issues: +1. **Check vision context**: If `vision.md` exists, read it to understand current goals and focus +2. **Understand the feature**: Analyze what "$1" involves +3. **Explore the codebase** if needed to understand context +4. **Break down** into discrete, actionable issues: - Each issue should be independently completable - Clear dependencies between issues - Appropriate scope (not too big, not too small) -4. **Present the plan**: +5. **Present the plan** (include vision alignment if vision exists): ``` ## Proposed Issues for: $1 + Vision Alignment: Supports [Goal N: description] + 1. [Title] - Brief description Dependencies: none + Supports: Goal N 2. [Title] - Brief description Dependencies: #1 + Supports: Goal N 3. [Title] - Brief description Dependencies: #1, #2 + Supports: Goal N ``` -5. **Ask for approval** before creating issues -6. **Create issues** in order -7. **Update dependencies** with actual issue numbers after creation -8. **Present summary** with links to created issues + If the feature doesn't align with any vision goal, note this and ask if: + - The vision should be updated to include this as a goal + - This should be added as a non-goal + - Proceed anyway (with justification) + +6. **Ask for approval** before creating issues +7. **Create issues** in order +8. **Update dependencies** with actual issue numbers after creation +9. **Present summary** with links to created issues diff --git a/commands/retro.md b/commands/retro.md index cc884b1..12708eb 100644 --- a/commands/retro.md +++ b/commands/retro.md @@ -1,11 +1,13 @@ --- -description: Run a retrospective on completed work. Captures learnings and creates improvement issues in the AI repo. +description: Run a retrospective on completed work. Captures learnings, creates improvement issues, and updates product vision. argument-hint: [task-description] --- # Retrospective -Capture learnings from completed AI-assisted work to improve the workflow. +Capture learnings from completed AI-assisted work to improve the workflow and refine the product vision. + +@~/.claude/skills/vision-management/SKILL.md ## Process @@ -22,7 +24,18 @@ Capture learnings from completed AI-assisted work to improve the workflow. - **Tool issues**: Problems with tea CLI, git, or other tools - **Context gaps**: Missing documentation or skills -4. **Generate improvement issues**: For each actionable improvement, create an issue in the AI repo using: +4. **Connect to vision** (if `vision.md` exists in the target repo): + - Did this work make progress on any vision goals? + - Did learnings reveal new priorities that should become goals? + - Did we discover something that should be a non-goal? + - Should the current focus shift based on what we learned? + + If any vision updates are needed: + - Present suggested changes to `vision.md` + - Ask for approval + - Update the vision file and sync to Gitea + +5. **Generate improvement issues**: For each actionable improvement, create an issue in the AI repo using: ```bash tea issues create -r flowmade-one/ai --title "" --description "<body>" diff --git a/commands/vision.md b/commands/vision.md new file mode 100644 index 0000000..992d1b5 --- /dev/null +++ b/commands/vision.md @@ -0,0 +1,72 @@ +--- +description: View, create, or update the product vision. Manages vision.md and syncs to Gitea. +argument-hint: [update|goals|focus] +--- + +# Product Vision + +@~/.claude/skills/vision-management/SKILL.md +@~/.claude/skills/gitea/SKILL.md + +## Process + +1. **Check for existing vision**: Look for `vision.md` in the current repo root. + +2. **If no vision exists**: + - Ask the user if they want to create one + - Guide them through: + - Purpose: Why does this product exist? + - Goals: 3-5 measurable outcomes with success metrics + - Current focus: Which 1-2 goals are priorities now? + - Non-goals: What are you explicitly NOT doing? + - Create `vision.md` with the vision document structure + - Create a Gitea issue labeled `vision` with the same content + +3. **If vision exists**: + - Display the current vision + - Check if $1 specifies an action: + - `update`: General update to the vision + - `goals`: Add, modify, or complete goals + - `focus`: Change the current focus area + - If no action specified, ask what the user wants to do: + - View only (done) + - Update goals + - Change focus + - Update progress + - Add non-goals + - Make the requested changes + - Update `vision.md` + - Sync changes to the Gitea vision issue + +4. **Sync to Gitea**: + - Find existing issue with `vision` label: `tea issues -l vision` + - If exists: Update the issue description + - If not: Create new issue with `vision` label + +## Output Format + +When displaying the vision, show it clearly: + +``` +## Current Vision + +**Purpose**: [purpose] + +**Goals**: +1. [Goal] - [Metric] [Progress indicator] +2. [Goal] - [Metric] [Progress indicator] + +**Current Focus**: [focus area] + +**Non-Goals**: [list] + +**Last Updated**: [date] +``` + +## Guidelines + +- Keep goals specific and measurable +- Limit to 3-5 active goals +- Current focus should be 1-2 goals max +- Update "Last Updated" on every change +- Always sync to Gitea after changes diff --git a/skills/vision-management/SKILL.md b/skills/vision-management/SKILL.md new file mode 100644 index 0000000..92c6d4f --- /dev/null +++ b/skills/vision-management/SKILL.md @@ -0,0 +1,156 @@ +--- +name: vision-management +description: Create, maintain, and evolve a product vision. Use when initializing a vision, updating goals, aligning work with vision, or connecting learnings to vision refinement. +--- + +# Vision Management + +How to create, maintain, and evolve a product vision for continuous improvement. + +## Vision Document Location + +The vision lives in two places: + +1. **`vision.md`** at repo root - Source of truth, versionable +2. **Gitea issue** labeled `vision` - Integrates with issue workflow + +Keep these in sync. The file is authoritative; the issue mirrors it. + +## Vision Document Structure + +```markdown +# Product Vision + +## Purpose +Why this product exists. The problem it solves. + +## Goals +1. [Goal 1] - [Success metric] +2. [Goal 2] - [Success metric] +3. [Goal 3] - [Success metric] + +## Current Focus +What we're prioritizing now and why. + +## Non-Goals +What we're explicitly NOT doing. + +## Progress +- [Goal 1]: [Status/progress] +- [Goal 2]: [Status/progress] + +## Last Updated +[Date] - [What changed] +``` + +## Creating a Vision + +When no vision exists: + +1. **Identify the purpose**: What problem does this product solve? Who benefits? +2. **Define 3-5 goals**: Concrete, measurable outcomes +3. **Set success metrics**: How will you know each goal is achieved? +4. **Choose current focus**: Which 1-2 goals are priorities right now? +5. **Document non-goals**: What are you explicitly NOT doing? + +### Good Goals + +- Specific and measurable +- Outcome-focused (not activity-focused) +- Have clear success criteria + +| Bad | Good | +|-----|------| +| "Improve performance" | "Page load under 2 seconds" | +| "Better UX" | "User can complete checkout in under 60 seconds" | +| "More features" | "Support 3 export formats (CSV, JSON, PDF)" | + +## Updating the Vision + +Update the vision when: + +- A goal is achieved (update progress, possibly add new goal) +- Learnings from retros reveal new priorities +- Strategic direction changes +- A non-goal becomes a goal (or vice versa) + +### Update Process + +1. Read current vision +2. Identify what needs to change +3. Draft the update +4. Present changes for approval +5. Update `vision.md` +6. Sync to Gitea issue + +## Aligning Issues with Vision + +When creating or reviewing issues: + +1. **Check goal alignment**: Does this issue support a vision goal? +2. **Tag appropriately**: Reference the goal in the issue description +3. **Prioritize by vision**: Issues supporting current focus get priority +4. **Flag misalignment**: Issues that don't align with any goal need justification + +### Alignment Check Template + +```markdown +## Vision Alignment +Supports: Goal 2 (Security) +Priority: High (current focus area) +``` + +### Identifying Gaps + +Compare vision goals to current backlog: + +- Which goals have no supporting issues? +- Which goals have stalled (no recent progress)? +- Are there issues that don't align with any goal? + +## Connecting Retros to Vision + +After a retrospective: + +1. **Review learnings**: Any that affect the vision? +2. **Goal changes**: Should any goals be added, removed, or modified? +3. **Non-goal additions**: Did we learn something we should explicitly avoid? +4. **Progress updates**: Did completed work advance any goals? + +### Retro-to-Vision Questions + +- "Did this work reveal a new priority we should add as a goal?" +- "Did we learn something that should become a non-goal?" +- "Should our current focus shift based on what we learned?" +- "Did this work make progress on any goals?" + +## Vision Issue in Gitea + +Create/update a Gitea issue that mirrors the vision: + +```bash +# Create vision issue +tea issues create --title "Product Vision" --description "$(cat vision.md)" --labels "vision" + +# Update existing vision issue +tea issues edit <issue-number> --description "$(cat vision.md)" +``` + +Benefits of the vision issue: +- Other issues can reference it (`Supports #N`) +- Visible in backlog alongside work items +- Provides discussion space for vision questions + +## Continuous Improvement Loop + +``` +Vision → Issues → Work → Retro → Vision (updated) +``` + +1. **Vision** defines what success looks like +2. **Issues** are created to achieve vision goals +3. **Work** implements the issues +4. **Retros** capture learnings from the work +5. **Vision updates** incorporate learnings (loop continues) + +The vision is a living document that evolves as you learn.