leedab 0.5.3 → 0.6.1

package/context/skills/product-skills.md

@@ -0,0 +1,569 @@
+# Product Agent Skills
+
+> Sourced from alirezarezvani/claude-skills (MIT License)
+
+---
+---
+name: "product-manager-toolkit"
+description: Comprehensive toolkit for product managers including RICE prioritization, customer interview analysis, PRD templates, discovery frameworks, and go-to-market strategies. Use for feature prioritization, user research synthesis, requirement documentation, and product strategy development.
+---
+
+# Product Manager Toolkit
+
+Essential tools and frameworks for modern product management, from discovery to delivery.
+
+---
+
+## Table of Contents
+
+- [Quick Start](#quick-start)
+- [Core Workflows](#core-workflows)
+  - [Feature Prioritization](#feature-prioritization-process)
+  - [Customer Discovery](#customer-discovery-process)
+  - [PRD Development](#prd-development-process)
+- [Tools Reference](#tools-reference)
+  - [RICE Prioritizer](#rice-prioritizer)
+  - [Customer Interview Analyzer](#customer-interview-analyzer)
+- [Input/Output Examples](#inputoutput-examples)
+- [Integration Points](#integration-points)
+- [Common Pitfalls](#common-pitfalls-to-avoid)
+
+---
+
+## Quick Start
+
+### For Feature Prioritization
+```bash
+# Create sample data file
+python scripts/rice_prioritizer.py sample
+
+# Run prioritization with team capacity
+python scripts/rice_prioritizer.py sample_features.csv --capacity 15
+```
+
+### For Interview Analysis
+```bash
+python scripts/customer_interview_analyzer.py interview_transcript.txt
+```
+
+### For PRD Creation
+1. Choose template from `references/prd_templates.md`
+2. Fill sections based on discovery work
+3. Review with engineering for feasibility
+4. Version control in project management tool
+
+---
+
+## Core Workflows
+
+### Feature Prioritization Process
+
+```
+Gather → Score → Analyze → Plan → Validate → Execute
+```
+
+#### Step 1: Gather Feature Requests
+- Customer feedback (support tickets, interviews)
+- Sales requests (CRM pipeline blockers)
+- Technical debt (engineering input)
+- Strategic initiatives (leadership goals)
+
+#### Step 2: Score with RICE
+```bash
+# Input: CSV with features
+python scripts/rice_prioritizer.py features.csv --capacity 20
+```
+
+See `references/frameworks.md` for RICE formula and scoring guidelines.
+
+#### Step 3: Analyze Portfolio
+Review the tool output for:
+- Quick wins vs big bets distribution
+- Effort concentration (avoid all XL projects)
+- Strategic alignment gaps
+
+#### Step 4: Generate Roadmap
+- Quarterly capacity allocation
+- Dependency identification
+- Stakeholder communication plan
+
+#### Step 5: Validate Results
+**Before finalizing the roadmap:**
+- [ ] Compare top priorities against strategic goals
+- [ ] Run sensitivity analysis (what if estimates are wrong by 2x?)
+- [ ] Review with key stakeholders for blind spots
+- [ ] Check for missing dependencies between features
+- [ ] Validate effort estimates with engineering
+
+#### Step 6: Execute and Iterate
+- Share roadmap with team
+- Track actual vs estimated effort
+- Revisit priorities quarterly
+- Update RICE inputs based on learnings
+
+---
+
+### Customer Discovery Process
+
+```
+Plan → Recruit → Interview → Analyze → Synthesize → Validate
+```
+
+#### Step 1: Plan Research
+- Define research questions
+- Identify target segments
+- Create interview script (see `references/frameworks.md`)
+
+#### Step 2: Recruit Participants
+- 5-8 interviews per segment
+- Mix of power users and churned users
+- Incentivize appropriately
+
+#### Step 3: Conduct Interviews
+- Use semi-structured format
+- Focus on problems, not solutions
+- Record with permission
+- Take minimal notes during interview
+
+#### Step 4: Analyze Insights
+```bash
+python scripts/customer_interview_analyzer.py transcript.txt
+```
+
+Extracts:
+- Pain points with severity
+- Feature requests with priority
+- Jobs to be done patterns
+- Sentiment and key themes
+- Notable quotes
+
+#### Step 5: Synthesize Findings
+- Group similar pain points across interviews
+- Identify patterns (3+ mentions = pattern)
+- Map to opportunity areas using Opportunity Solution Tree
+- Prioritize opportunities by frequency and severity
+
+#### Step 6: Validate Solutions
+**Before building:**
+- [ ] Create solution hypotheses (see `references/frameworks.md`)
+- [ ] Test with low-fidelity prototypes
+- [ ] Measure actual behavior vs stated preference
+- [ ] Iterate based on feedback
+- [ ] Document learnings for future research
+
+---
+
+### PRD Development Process
+
+```
+Scope → Draft → Review → Refine → Approve → Track
+```
+
+#### Step 1: Choose Template
+Select from `references/prd_templates.md`:
+
+| Template | Use Case | Timeline |
+|----------|----------|----------|
+| Standard PRD | Complex features, cross-team | 6-8 weeks |
+| One-Page PRD | Simple features, single team | 2-4 weeks |
+| Feature Brief | Exploration phase | 1 week |
+| Agile Epic | Sprint-based delivery | Ongoing |
+
+#### Step 2: Draft Content
+- Lead with problem statement
+- Define success metrics upfront
+- Explicitly state out-of-scope items
+- Include wireframes or mockups
+
+#### Step 3: Review Cycle
+- Engineering: feasibility and effort
+- Design: user experience gaps
+- Sales: market validation
+- Support: operational impact
+
+#### Step 4: Refine Based on Feedback
+- Address technical constraints
+- Adjust scope to fit timeline
+- Document trade-off decisions
+
+#### Step 5: Approval and Kickoff
+- Stakeholder sign-off
+- Sprint planning integration
+- Communication to broader team
+
+#### Step 6: Track Execution
+**After launch:**
+- [ ] Compare actual metrics vs targets
+- [ ] Conduct user feedback sessions
+- [ ] Document what worked and what didn't
+- [ ] Update estimation accuracy data
+- [ ] Share learnings with team
+
+---
+
+## Tools Reference
+
+### RICE Prioritizer
+
+Advanced RICE framework implementation with portfolio analysis.
+
+**Features:**
+- RICE score calculation with configurable weights
+- Portfolio balance analysis (quick wins vs big bets)
+- Quarterly roadmap generation based on capacity
+- Multiple output formats (text, JSON, CSV)
+
+**CSV Input Format:**
+```csv
+name,reach,impact,confidence,effort,description
+User Dashboard Redesign,5000,high,high,l,Complete redesign
+Mobile Push Notifications,10000,massive,medium,m,Add push support
+Dark Mode,8000,medium,high,s,Dark theme option
+```
+
+**Commands:**
+```bash
+# Create sample data
+python scripts/rice_prioritizer.py sample
+
+# Run with default capacity (10 person-months)
+python scripts/rice_prioritizer.py features.csv
+
+# Custom capacity
+python scripts/rice_prioritizer.py features.csv --capacity 20
+
+# JSON output for integration
+python scripts/rice_prioritizer.py features.csv --output json
+
+# CSV output for spreadsheets
+python scripts/rice_prioritizer.py features.csv --output csv
+```
+
+---
+
+### Customer Interview Analyzer
+
+NLP-based interview analysis for extracting actionable insights.
+
+**Capabilities:**
+- Pain point extraction with severity assessment
+- Feature request identification and classification
+- Jobs-to-be-done pattern recognition
+- Sentiment analysis per section
+- Theme and quote extraction
+- Competitor mention detection
+
+**Commands:**
+```bash
+# Analyze interview transcript
+python scripts/customer_interview_analyzer.py interview.txt
+
+# JSON output for aggregation
+python scripts/customer_interview_analyzer.py interview.txt json
+```
+
+---
+
+## Input/Output Examples
+→ See references/input-output-examples.md for details
+
+## Integration Points
+
+Compatible tools and platforms:
+
+| Category | Platforms |
+|----------|-----------|
+| **Analytics** | Amplitude, Mixpanel, Google Analytics |
+| **Roadmapping** | ProductBoard, Aha!, Roadmunk, Productplan |
+| **Design** | Figma, Sketch, Miro |
+| **Development** | Jira, Linear, GitHub, Asana |
+| **Research** | Dovetail, UserVoice, Pendo, Maze |
+| **Communication** | Slack, Notion, Confluence |
+
+**JSON export enables integration with most tools:**
+```bash
+# Export for Jira import
+python scripts/rice_prioritizer.py features.csv --output json > priorities.json
+
+# Export for dashboard
+python scripts/customer_interview_analyzer.py interview.txt json > insights.json
+```
+
+---
+
+## Common Pitfalls to Avoid
+
+| Pitfall | Description | Prevention |
+|---------|-------------|------------|
+| **Solution-First** | Jumping to features before understanding problems | Start every PRD with problem statement |
+| **Analysis Paralysis** | Over-researching without shipping | Set time-boxes for research phases |
+| **Feature Factory** | Shipping features without measuring impact | Define success metrics before building |
+| **Ignoring Tech Debt** | Not allocating time for platform health | Reserve 20% capacity for maintenance |
+| **Stakeholder Surprise** | Not communicating early and often | Weekly async updates, monthly demos |
+| **Metric Theater** | Optimizing vanity metrics over real value | Tie metrics to user value delivered |
+
+---
+
+## Best Practices
+
+**Writing Great PRDs:**
+- Start with the problem, not the solution
+- Include clear success metrics upfront
+- Explicitly state what's out of scope
+- Use visuals (wireframes, flows, diagrams)
+- Keep technical details in appendix
+- Version control all changes
+
+**Effective Prioritization:**
+- Mix quick wins with strategic bets
+- Consider opportunity cost of delays
+- Account for dependencies between features
+- Buffer 20% for unexpected work
+- Revisit priorities quarterly
+- Communicate decisions with context
+
+**Customer Discovery:**
+- Ask "why" five times to find root cause
+- Focus on past behavior, not future intentions
+- Avoid leading questions ("Wouldn't you love...")
+- Interview in the user's natural environment
+- Watch for emotional reactions (pain = opportunity)
+- Validate qualitative with quantitative data
+
+---
+
+## Quick Reference
+
+```bash
+# Prioritization
+python scripts/rice_prioritizer.py features.csv --capacity 15
+
+# Interview Analysis
+python scripts/customer_interview_analyzer.py interview.txt
+
+# Generate sample data
+python scripts/rice_prioritizer.py sample
+
+# JSON outputs
+python scripts/rice_prioritizer.py features.csv --output json
+python scripts/customer_interview_analyzer.py interview.txt json
+```
+
+---
+
+## Reference Documents
+
+- `references/prd_templates.md` - PRD templates for different contexts
+- `references/frameworks.md` - Detailed framework documentation (RICE, MoSCoW, Kano, JTBD, etc.)
+
+---
+
+---
+name: product-discovery
+description: Use when validating product opportunities, mapping assumptions, planning discovery sprints, or testing problem-solution fit before committing delivery resources.
+---
+
+# Product Discovery
+
+Run structured discovery to identify high-value opportunities and de-risk product bets.
+
+## When To Use
+
+Use this skill for:
+- Opportunity Solution Tree facilitation
+- Assumption mapping and test planning
+- Problem validation interviews and evidence synthesis
+- Solution validation with prototypes/experiments
+- Discovery sprint planning and outputs
+
+## Core Discovery Workflow
+
+1. Define desired outcome
+- Set one measurable outcome to improve.
+- Establish baseline and target horizon.
+
+2. Build Opportunity Solution Tree (OST)
+- Outcome -> opportunities -> solution ideas -> experiments
+- Keep opportunities grounded in user evidence, not internal opinions.
+
+3. Map assumptions
+- Identify desirability, viability, feasibility, and usability assumptions.
+- Score assumptions by risk and certainty.
+
+Use:
+```bash
+python3 scripts/assumption_mapper.py assumptions.csv
+```
+
+4. Validate the problem
+- Conduct interviews and behavior analysis.
+- Confirm frequency, severity, and willingness to solve.
+- Reject weak opportunities early.
+
+5. Validate the solution
+- Prototype before building.
+- Run concept, usability, and value tests.
+- Measure behavior, not only stated preference.
+
+6. Plan discovery sprint
+- 1-2 week cycle with explicit hypotheses
+- Daily evidence reviews
+- End with decision: proceed, pivot, or stop
+
+## Opportunity Solution Tree (Teresa Torres)
+
+Structure:
+- Outcome: metric you want to move
+- Opportunities: unmet customer needs/pains
+- Solutions: candidate interventions
+- Experiments: fastest learning actions
+
+Quality checks:
+- At least 3 distinct opportunities before converging.
+- At least 2 experiments per top opportunity.
+- Tie every branch to evidence source.
+
+## Assumption Mapping
+
+Assumption categories:
+- Desirability: users want this
+- Viability: business value exists
+- Feasibility: team can build/operate it
+- Usability: users can successfully use it
+
+Prioritization rule:
+- High risk + low certainty assumptions are tested first.
+
+## Problem Validation Techniques
+
+- Problem interviews focused on current behavior
+- Journey friction mapping
+- Support ticket and sales-call synthesis
+- Behavioral analytics triangulation
+
+Evidence threshold examples:
+- Same pain repeated across multiple target users
+- Observable workaround behavior
+- Measurable cost of current pain
+
+## Solution Validation Techniques
+
+- Concept tests (value proposition comprehension)
+- Prototype usability tests (task success/time-to-complete)
+- Fake door or concierge tests (demand signal)
+- Limited beta cohorts (retention/activation signals)
+
+## Discovery Sprint Planning
+
+Suggested 10-day structure:
+- Day 1-2: Outcome + opportunity framing
+- Day 3-4: Assumption mapping + test design
+- Day 5-7: Problem and solution tests
+- Day 8-9: Evidence synthesis + decision options
+- Day 10: Stakeholder decision review
+
+## Tooling
+
+### `scripts/assumption_mapper.py`
+
+CLI utility that:
+- reads assumptions from CSV or inline input
+- scores risk/certainty priority
+- emits prioritized test plan with suggested test types
+
+See `references/discovery-frameworks.md` for framework details.
+
+---
+
+---
+name: roadmap-communicator
+description: Use when preparing roadmap narratives, release notes, changelogs, or stakeholder updates tailored for executives, engineering teams, and customers.
+---
+
+# Roadmap Communicator
+
+Create clear roadmap communication artifacts for internal and external stakeholders.
+
+## When To Use
+
+Use this skill for:
+- Building roadmap presentations in different formats
+- Writing stakeholder updates (board, engineering, customers)
+- Producing release notes (user-facing and internal)
+- Generating changelogs from git history
+- Structuring feature announcements
+
+## Roadmap Formats
+
+1. Now / Next / Later
+- Best for uncertainty and strategic flexibility.
+- Communicate direction without false precision.
+
+2. Timeline roadmap
+- Best for fixed-date commitments and launch coordination.
+- Requires active risk and dependency management.
+
+3. Theme-based roadmap
+- Best for outcome-led planning and cross-team alignment.
+- Groups initiatives by problem space or strategic objective.
+
+See `references/roadmap-templates.md` for templates.
+
+## Stakeholder Update Patterns
+
+### Board / Executive
+- Outcome and risk oriented
+- Focus on progress against strategic goals
+- Highlight trade-offs and required decisions
+
+### Engineering
+- Scope, dependencies, and sequencing clarity
+- Status, blockers, and resourcing implications
+
+### Customers
+- Value narrative and timing window
+- What is available now vs upcoming
+- Clear expectation setting
+
+See `references/communication-templates.md` for reusable templates.
+
+## Release Notes Guidance
+
+### User-Facing Release Notes
+- Lead with user value, not internal implementation details.
+- Group by workflows or user jobs.
+- Include migration/behavior changes explicitly.
+
+### Internal Release Notes
+- Include technical details, operational impact, and known issues.
+- Capture rollout plan, rollback criteria, and monitoring notes.
+
+## Changelog Generation
+
+Use:
+```bash
+python3 scripts/changelog_generator.py --from v1.0.0 --to HEAD
+```
+
+Features:
+- Reads git log range
+- Parses conventional commit prefixes
+- Groups entries by type (`feat`, `fix`, `chore`, etc.)
+- Outputs markdown or plain text
+
+## Feature Announcement Framework
+
+1. Problem context
+2. What changed
+3. Why it matters
+4. Who benefits most
+5. How to get started
+6. Call to action and feedback channel
+
+## Communication Quality Checklist
+
+- [ ] Audience-specific framing is explicit.
+- [ ] Outcomes and trade-offs are clear.
+- [ ] Terminology is consistent across artifacts.
+- [ ] Risks and dependencies are not hidden.
+- [ ] Next actions and owners are specified.

package/context/skills/research-skills.md

@@ -0,0 +1,62 @@
+# Research — Skill Pack
+
+## Source hierarchy (use the strongest available)
+1. **Primary, official** — SEC filings, ASIC company extract, ABN lookup, official government datasets, the company's own filings or press releases on their domain.
+2. **Primary, public** — founder posts on their own channels, public earnings calls, regulatory dockets, court records.
+3. **Reputable secondary** — established trade press (e.g. The Loadstar for logistics, The Information for tech), analyst firms with disclosed methodology.
+4. **Aggregators** — Crunchbase, Owler, Pitchbook (when accessible). Confidence drops a step.
+5. **Marketing-driven** — vendor's own product pages, sponsored content. Low confidence; cross-check before citing.
+
+## Citation format (default)
+```
+[1] Source title — Publisher — URL — Accessed YYYY-MM-DD — Confidence: H/M/L
+```
+
+Inline mark a claim with `[1]`. Footnote at the bottom of the document.
+
+## When you can't find a source
+Say so explicitly: `(unverified — couldn't find a primary or reputable secondary source as of {date})`. Never substitute confidence for evidence.
+
+## Market sizing — show your math
+Default formula: TAM = #segments × ARPU × frequency. Each input cited. Show the calculation. State assumptions. Range the estimate (low / base / high) — single-point estimates are false precision.
+
+## Prospect deep-dive checklist
+- Legal name + entity number + jurisdiction
+- Industry + sub-vertical (be specific — "logistics" is not enough)
+- Revenue band (cite source — IBISWorld, ZoomInfo, founder LinkedIn for "we hit $Xm")
+- Headcount band + recent hiring trend (LinkedIn jobs page, careers page)
+- Tech stack signals (BuiltWith, Wappalyzer, careers page tooling mentions)
+- Recent moves: funding (Crunchbase / press), exec changes (LinkedIn announcements), product launches (their newsroom)
+- Decision-makers: by name where public, with role + likely deal influence
+- Public pain points: complaints / reviews / forum mentions
+- Trigger to reach out now: specific reason, dated, defensible
+
+## Competitive analysis — pick a comparison axis
+Don't list features in random order. Pick the 4–6 axes that actually decide deals in this category:
+- For logistics SaaS: deployment model, voice channels, computer-use vs API, local vs cloud, pricing model.
+- For dev tools: team size sweet spot, language coverage, IDE integration, on-prem option, pricing.
+- For finance tools: accounting system integrations, multi-entity, multi-currency, audit trail, jurisdiction coverage.
+
+Always end with "where each one wins" — competitors win at *something*, naming it makes you trustworthy.
+
+## Confidence vocabulary
+- **Likely / probably**: > 70% confidence based on triangulating two or more sources.
+- **Possibly**: 30–70% — single source, or strong inference from indirect signals.
+- **Speculative**: < 30% — flag clearly, don't anchor decisions on it.
+
+## Background checks — what's defensible vs what isn't
+- ✅ Public company filings, court records (where searchable), regulatory disclosures.
+- ✅ Their own LinkedIn / blog / talks.
+- ✅ Press coverage with named sources.
+- ❌ Anonymous Glassdoor reviews as evidence of culture.
+- ❌ Single-source rumours from gossip sites.
+- ❌ Anything you'd be embarrassed to point to in court.
+
+## Tools to know
+- BuiltWith, Wappalyzer (tech stack), SimilarWeb (traffic estimates — directional only), Owler (competitive snapshots — directional), ASIC Connect (AU companies), SEC EDGAR (US filings).
+
+## Don't
+- Pad a brief to look thorough. A tight 1-page brief beats a 15-page dossier of low-quality material.
+- Cite competitor marketing pages as evidence for their performance.
+- Invent named sources or quotes.
+- Conflate what a CEO *said in an earnings call* with *what the company is actually doing*.