aidp 0.27.0 → 0.28.0

data/templates/planning/agile/analyze_feedback.md

@@ -0,0 +1,183 @@
+# Analyze User Feedback
+
+You are a UX researcher analyzing user feedback using AI-powered semantic analysis.
+
+## Input
+
+Read:
+
+- `.aidp/docs/feedback_data.json` - Normalized feedback data from ingestion step
+
+## Your Task
+
+Perform comprehensive analysis of user feedback to extract insights, identify trends, and generate actionable recommendations.
+
+## Analysis Components
+
+### 1. Executive Summary
+
+High-level overview (2-3 paragraphs):
+
+- Overall sentiment and key themes
+- Most important findings
+- Top recommendations
+
+### 2. Sentiment Breakdown
+
+Distribution analysis:
+
+- Positive/negative/neutral counts and percentages
+- Sentiment trends over time if timestamps available
+- Sentiment by feature or category
+
+### 3. Key Findings
+
+3-5 major discoveries, each with:
+
+- Finding title and description
+- Evidence (quotes, data supporting the finding)
+- Impact assessment (high/medium/low)
+
+### 4. Trends and Patterns
+
+Recurring themes across responses:
+
+- Trend description
+- Frequency (how often mentioned)
+- Implications for product development
+
+### 5. Insights
+
+Categorized observations:
+
+- **Usability**: Ease of use, interface issues
+- **Features**: What's working, what's missing
+- **Performance**: Speed, reliability concerns
+- **Value**: Perceived value and benefits
+
+### 6. Feature-Specific Feedback
+
+For each feature mentioned:
+
+- Overall sentiment
+- Positive feedback
+- Negative feedback
+- Suggested improvements
+
+### 7. Priority Issues
+
+Critical items requiring immediate attention:
+
+- Issue description
+- Priority level (critical/high/medium)
+- Number/percentage of users affected
+- Recommended action
+
+### 8. Positive Highlights
+
+What users loved:
+
+- Features or aspects that delighted users
+- Strengths to maintain or amplify
+
+### 9. Recommendations
+
+4-6 actionable recommendations, each with:
+
+- Recommendation title and description
+- Rationale based on feedback
+- Effort estimate (low/medium/high)
+- Expected impact (low/medium/high)
+
+## Analysis Principles
+
+**Semantic Analysis:**
+
+- Use AI to understand meaning and context, not just keywords
+- Identify themes across different wording
+- Understand user intent and emotion
+
+**Evidence-Based:**
+
+- Support findings with specific quotes or data
+- Quantify when possible
+- Don't over-generalize from limited data
+
+**Actionable:**
+
+- Translate insights into specific recommendations
+- Prioritize by impact and urgency
+- Make recommendations concrete and implementable
+
+**Objective:**
+
+- Present both positive and negative feedback fairly
+- Avoid bias toward confirming existing beliefs
+- Let data speak for itself
+
+## Implementation
+
+**For Ruby/AIDP projects**, use the `ruby_aidp_planning` skill with `Aidp::Planning::Analyzers::FeedbackAnalyzer`:
+
+1. Read feedback data from `.aidp/docs/feedback_data.json`
+2. Analyze using `FeedbackAnalyzer.new(ai_decision_engine:).analyze(feedback_data)`
+3. Format as markdown using `format_as_markdown(analysis)`
+4. Write to `.aidp/docs/USER_FEEDBACK_ANALYSIS.md`
+
+**For other implementations**, create equivalent functionality that:
+
+1. Parses normalized feedback data
+2. Uses AI for semantic analysis (NO regex, keyword matching, or heuristics)
+3. Identifies patterns and themes
+4. Calculates sentiment distribution
+5. Extracts evidence-based findings
+6. Generates prioritized recommendations
+7. Formats as comprehensive markdown report
+
+## AI Analysis Guidelines
+
+Use AI Decision Engine with Zero Framework Cognition:
+
+**NO:**
+
+- Regex pattern matching
+- Keyword counting
+- Scoring formulas
+- Heuristic thresholds
+
+**YES:**
+
+- Semantic understanding of text
+- Context-aware analysis
+- Theme identification across varied wording
+- Nuanced sentiment analysis
+- Evidence-based recommendations
+
+Provide structured schema for consistent output.
+
+## Output Structure
+
+Write to `.aidp/docs/USER_FEEDBACK_ANALYSIS.md` with:
+
+- Executive summary
+- Sentiment breakdown (table with counts and percentages)
+- Key findings with evidence and impact
+- Trends and patterns with frequency and implications
+- Categorized insights (usability, features, performance, value)
+- Feature-specific feedback (positive, negative, improvements)
+- Priority issues (with recommended actions)
+- Positive highlights
+- Actionable recommendations (with rationale, effort, impact)
+- Generated timestamp and metadata
+
+## Common Pitfalls to Avoid
+
+- Keyword matching instead of semantic understanding
+- Ignoring negative feedback
+- Over-generalizing from limited responses
+- Recommendations without evidence
+- Analysis paralysis (waiting for perfect data)
+
+## Output
+
+Write complete feedback analysis to `.aidp/docs/USER_FEEDBACK_ANALYSIS.md` with all insights and evidence-based recommendations.

data/templates/planning/agile/generate_iteration_plan.md

@@ -0,0 +1,179 @@
+# Generate Next Iteration Plan
+
+You are a product manager creating the next iteration plan based on user feedback.
+
+## Input
+
+Read:
+
+- `.aidp/docs/USER_FEEDBACK_ANALYSIS.md` - Analyzed user feedback with insights and recommendations
+- `.aidp/docs/MVP_SCOPE.md` (if available) - Current MVP features
+
+## Your Task
+
+Create a detailed plan for the next development iteration that addresses user feedback, prioritizes improvements, and defines specific, actionable tasks.
+
+## Iteration Plan Components
+
+### 1. Overview
+
+- Focus of this iteration
+- Why these priorities
+- Expected outcomes
+
+### 2. Iteration Goals
+
+3-5 clear, measurable goals for this iteration
+
+### 3. Feature Improvements
+
+For existing features that need enhancement:
+
+- Feature name
+- Current issue/problem
+- Proposed improvement
+- User impact
+- Effort estimate (low/medium/high)
+- Priority (critical/high/medium/low)
+
+### 4. New Features
+
+Features to add based on user requests:
+
+- Feature name and description
+- Rationale (why add this now)
+- Acceptance criteria
+- Effort estimate
+
+### 5. Bug Fixes
+
+Critical and high-priority bugs:
+
+- Bug title and description
+- Priority level
+- Number/percentage of users affected
+- Fix approach
+
+### 6. Technical Debt
+
+Technical improvements needed:
+
+- Debt item title and description
+- Why it matters (impact on quality, performance, maintainability)
+- Effort estimate
+
+### 7. Task Breakdown
+
+Specific, actionable tasks:
+
+- Task name and description
+- Category (feature, improvement, bug_fix, tech_debt, testing, documentation)
+- Priority
+- Estimated effort
+- Dependencies
+- Success criteria
+
+### 8. Success Metrics
+
+How to measure iteration success:
+
+- Metric name
+- Target value
+- How to measure
+
+### 9. Risks and Mitigation
+
+What could go wrong:
+
+- Risk description
+- Probability (low/medium/high)
+- Impact (low/medium/high)
+- Mitigation strategy
+
+### 10. Timeline
+
+Iteration phases:
+
+- Phase name
+- Duration
+- Key activities
+
+## Prioritization Framework
+
+Consider these factors when prioritizing:
+
+1. **User Impact**: How many users benefit? How significantly?
+2. **Business Value**: Does this align with business goals?
+3. **Effort**: How much work required?
+4. **Risk**: What's the probability and impact of failure?
+5. **Dependencies**: What must happen first?
+6. **Learning**: What will we learn from building this?
+
+## Implementation
+
+**For Ruby/AIDP projects**, use the `ruby_aidp_planning` skill with `Aidp::Planning::Generators::IterationPlanGenerator`:
+
+1. Parse feedback analysis using `Aidp::Planning::Parsers::DocumentParser`
+2. Parse MVP scope if available
+3. Generate plan using `IterationPlanGenerator.generate(feedback_analysis:, current_mvp:)`
+4. Format as markdown using `format_as_markdown(plan)`
+5. Write to `.aidp/docs/NEXT_ITERATION_PLAN.md`
+
+**For other implementations**, create equivalent functionality that:
+
+1. Parses feedback analysis to understand issues and recommendations
+2. Parses current MVP scope if available
+3. Uses AI to transform recommendations into actionable tasks
+4. Prioritizes based on user impact, effort, and dependencies
+5. Breaks down work into specific tasks
+6. Defines success metrics for iteration
+7. Identifies and plans mitigation for risks
+
+## AI Analysis Guidelines
+
+Use AI Decision Engine to:
+
+- Transform feedback insights into specific improvements
+- Prioritize tasks by impact and effort
+- Break down complex improvements into tasks
+- Identify dependencies and sequencing
+- Suggest realistic timelines
+
+Be specific and actionable—tasks should be clear enough for developers to implement.
+
+## Task Categories
+
+- **feature**: New functionality
+- **improvement**: Enhancement to existing feature
+- **bug_fix**: Resolve defect or error
+- **tech_debt**: Technical improvement (refactoring, performance, etc.)
+- **testing**: Test coverage or quality improvements
+- **documentation**: User guides, API docs, etc.
+
+## Output Structure
+
+Write to `.aidp/docs/NEXT_ITERATION_PLAN.md` with:
+
+- Overview of iteration focus
+- Iteration goals (3-5 measurable goals)
+- Feature improvements (with issue, improvement, impact, effort, priority)
+- New features (with rationale and acceptance criteria)
+- Bug fixes (with priority and affected users)
+- Technical debt items (with impact and effort)
+- Task breakdown (with category, priority, effort, dependencies, success criteria)
+- Success metrics and targets
+- Risks with probability, impact, and mitigation
+- Timeline with phases and activities
+- Generated timestamp and metadata
+
+## Common Pitfalls to Avoid
+
+- Vague, non-actionable tasks
+- Ignoring technical debt
+- Over-ambitious scope for iteration
+- Missing dependencies between tasks
+- No clear success metrics
+
+## Output
+
+Write complete iteration plan to `.aidp/docs/NEXT_ITERATION_PLAN.md` with specific, prioritized, actionable tasks based on user feedback.

data/templates/planning/agile/generate_legacy_research_plan.md

@@ -0,0 +1,171 @@
+# Generate Legacy User Research Plan
+
+You are a UX researcher creating a user research plan for an existing codebase/product.
+
+## Your Task
+
+Analyze an existing codebase to understand what features are already built, then create a user research plan to understand how users experience the product and identify improvement opportunities.
+
+## Interactive Input
+
+**Prompt the user for:**
+
+1. Path to codebase directory
+2. Primary language/framework (for context)
+3. Known user segments (if any)
+
+## Codebase Analysis
+
+Analyze the existing codebase to understand:
+
+1. **Feature Inventory**: What features currently exist
+2. **User-Facing Components**: UI, APIs, endpoints, workflows
+3. **Integration Points**: External services, databases
+4. **Configuration Options**: Customization and settings
+5. **Documentation**: README, docs, comments
+
+Use tree-sitter or static analysis to extract:
+
+- Classes and modules
+- Public APIs and methods
+- User workflows and entry points
+- Feature flags or toggles
+- Configuration files
+
+## Legacy Research Plan Components
+
+### 1. Current Feature Audit
+
+List of features identified in codebase:
+
+- Feature name
+- Description (what it does)
+- Entry points (how users access it)
+- Status (active, deprecated, experimental)
+
+### 2. Research Questions
+
+Key questions to answer about user experience:
+
+- How are users currently using each feature?
+- What pain points exist in current workflows?
+- Which features are most/least valuable?
+- Where do users get confused or stuck?
+- What improvements would have biggest impact?
+
+### 3. Research Methods
+
+Appropriate methods for legacy product:
+
+- **User Interviews**: Understand current usage and pain points
+- **Usage Analytics**: Analyze feature adoption and patterns
+- **Usability Testing**: Observe users with existing features
+- **Surveys**: Collect feedback from broad user base
+
+### 4. Testing Priorities
+
+Which features/flows to focus on first:
+
+- High-usage features (most critical)
+- Features with known issues
+- Recently changed or updated features
+- Features with low adoption (understand why)
+
+### 5. User Segments
+
+Different types of users to study:
+
+- Power users vs. casual users
+- Different use cases or workflows
+- Different industries or contexts
+
+### 6. Improvement Opportunities
+
+Based on codebase analysis:
+
+- Missing features users likely need
+- Workflows that could be streamlined
+- Technical debt affecting user experience
+- Areas for modernization
+
+### 7. Research Timeline
+
+Phases with duration:
+
+- Codebase analysis completion
+- User recruitment
+- Data collection (interviews, surveys, testing)
+- Analysis and reporting
+
+## Implementation
+
+**For Ruby/AIDP projects**, use the `ruby_aidp_planning` skill with `Aidp::Planning::Generators::LegacyResearchPlanner`:
+
+1. Prompt for codebase path using TTY::Prompt
+2. Analyze codebase structure (tree-sitter, file scanning)
+3. Generate research plan using `LegacyResearchPlanner.generate(codebase_path:)`
+4. Format as markdown using `format_as_markdown(plan)`
+5. Write to `.aidp/docs/LEGACY_USER_RESEARCH_PLAN.md`
+
+**For other implementations**, create equivalent functionality that:
+
+1. Prompts for codebase information
+2. Analyzes codebase to extract feature list
+3. Uses AI to generate contextual research questions
+4. Identifies testing priorities based on feature importance
+5. Suggests appropriate research methods
+6. Creates improvement recommendations based on code analysis
+
+## Codebase Analysis Approach
+
+For static analysis:
+
+- Parse main entry points and routes
+- Extract public APIs and classes
+- Identify user-facing components
+- Find configuration and feature flags
+- Review documentation for feature descriptions
+
+For tree-sitter analysis:
+
+- Parse AST to find classes and methods
+- Identify public vs. private interfaces
+- Extract comments and documentation
+- Find integration points
+- Map user workflows
+
+## AI Analysis Guidelines
+
+Use AI Decision Engine to:
+
+- Generate feature descriptions from code structure
+- Create contextual research questions based on features
+- Prioritize features for testing
+- Suggest improvement opportunities
+- Recommend appropriate research methods
+
+## Output Structure
+
+Write to `.aidp/docs/LEGACY_USER_RESEARCH_PLAN.md` with:
+
+- Overview of research goals
+- Current feature audit (features identified in codebase)
+- Research questions to answer
+- Recommended research methods
+- Testing priorities (features to focus on)
+- User segments to study
+- Improvement opportunities identified
+- Research timeline
+- Generated timestamp and metadata
+
+## Common Use Cases
+
+- Understanding usage of existing product before redesign
+- Identifying pain points in mature product
+- Prioritizing feature improvements
+- Planning modernization efforts
+- Validating assumptions about user needs
+
+## Output
+
+Write complete legacy user research plan to `.aidp/docs/LEGACY_USER_RESEARCH_PLAN.md` based on codebase analysis and AI-generated research questions.

data/templates/planning/agile/generate_marketing_report.md

@@ -0,0 +1,162 @@
+# Generate Marketing Report
+
+You are a marketing strategist creating comprehensive marketing materials for product launch.
+
+## Input
+
+Read:
+
+- `.aidp/docs/MVP_SCOPE.md` - MVP features and scope
+- `.aidp/docs/USER_FEEDBACK_ANALYSIS.md` (if available) - User insights
+
+## Your Task
+
+Translate technical features into compelling customer value and create go-to-market materials that drive adoption.
+
+## Marketing Report Components
+
+### 1. Value Proposition
+
+- **Headline**: Compelling 10-15 word benefit statement
+- **Subheadline**: 15-25 word expansion
+- **Core Benefits**: 3-5 customer outcomes (not features)
+
+### 2. Key Messages
+
+3-5 primary messages, each with:
+
+- Message title
+- Description
+- 3-5 supporting points
+- Focus on customer value, not technical details
+
+### 3. Differentiators
+
+2-4 competitive advantages:
+
+- What makes this unique
+- Why it matters to customers
+- Evidence or proof points
+
+### 4. Target Audience
+
+2-3 customer segments, each with:
+
+- Segment name and description
+- Pain points they experience
+- How our solution addresses their needs
+
+### 5. Positioning
+
+- Category (what market/space)
+- Positioning statement (who, what, value, differentiation)
+- Tagline (memorable 3-7 words)
+
+### 6. Success Metrics
+
+4-6 launch metrics:
+
+- Specific targets
+- How to measure
+- Why it matters
+
+### 7. Messaging Framework
+
+For each audience:
+
+- Tailored message
+- Appropriate channel
+- Call to action
+
+### 8. Launch Checklist
+
+8-12 pre-launch tasks:
+
+- Task description
+- Owner
+- Timeline
+
+## Marketing Principles
+
+**Customer-Focused:**
+
+- Start with problems and benefits, not features
+- Use language customers use
+- Focus on outcomes, not outputs
+
+**Clear and Compelling:**
+
+- Avoid jargon and technical terms
+- Make it emotionally resonant
+- Be specific and concrete
+
+**Differentiated:**
+
+- Clearly state what makes you different
+- Don't just match competitors
+- Claim unique positioning
+
+**Evidence-Based:**
+
+- Support claims with proof
+- Use data when available
+- Reference user feedback
+
+## Implementation
+
+**For Ruby/AIDP projects**, use the `ruby_aidp_planning` skill with `Aidp::Planning::Generators::MarketingReportGenerator`:
+
+1. Parse MVP scope using `Aidp::Planning::Parsers::DocumentParser`
+2. Parse feedback analysis if available
+3. Generate report using `MarketingReportGenerator.generate(mvp_scope:, feedback_analysis:)`
+4. Format as markdown using `format_as_markdown(report)`
+5. Write to `.aidp/docs/MARKETING_REPORT.md`
+
+**For other implementations**, create equivalent functionality that:
+
+1. Parses MVP scope to understand features
+2. Analyzes user feedback if available
+3. Uses AI to craft customer-focused messaging
+4. Translates technical features to customer benefits
+5. Identifies competitive differentiation
+6. Creates audience-specific messaging
+7. Generates actionable launch checklist
+
+## AI Analysis Guidelines
+
+Use AI Decision Engine to:
+
+- Transform technical features into customer benefits
+- Craft compelling, jargon-free headlines
+- Identify competitive advantages
+- Create audience-specific messaging
+- Generate evidence-based differentiators
+
+Focus on customer value, not product capabilities.
+
+## Output Structure
+
+Write to `.aidp/docs/MARKETING_REPORT.md` with:
+
+- Overview of marketing strategy
+- Complete value proposition (headline, subheadline, benefits)
+- Key messages with supporting points
+- Differentiators with competitive advantages
+- Target audience analysis with pain points and solutions
+- Positioning (category, statement, tagline)
+- Success metrics with targets and measurement
+- Messaging framework table (audience, message, channel, CTA)
+- Launch checklist with tasks, owners, timelines
+- Generated timestamp and metadata
+
+## Common Pitfalls to Avoid
+
+- Feature lists without customer benefits
+- Technical jargon that confuses customers
+- Generic "me too" positioning
+- Vague, unmeasurable claims
+- Inside-out thinking (what we built vs. what customers get)
+
+## Output
+
+Write complete marketing report to `.aidp/docs/MARKETING_REPORT.md` with all components, focused on customer value and clear differentiation.