project-mngt

What this skill does

# project-mngt

**Project Implementation Planning with MVP/MMP/MMR Methodology**

## Purpose

This skill teaches AI assistants how to analyze any project's requirements and create implementation plans using the MVP/MMP/MMR (Minimum Viable Product / Minimum Marketable Product / Minimum Marketable Release) methodology.

**This is a METHODOLOGY skill that teaches HOW to plan, not WHAT to plan.**

### Use Cases

1. **Initial Project Planning**: Analyze requirements and create structured implementation plan
2. **Plan Updates**: Modify existing plans when requirements change while preserving completed work
3. **Progress Tracking**: Update plans with current status and adjust remaining work
4. **Release Strategy**: Define logical stages and atomic groups for incremental delivery

### Adaptability

Works with:
- Any number of requirement documents (5 or 500)
- Different formats: BRD, PRD, User Stories, Epics, Features
- Various domains: Trading systems, web apps, APIs, infrastructure, ML/AI
- Changing requirements: Update plans without restarting completed work

### ID Naming Standards

**Reference**: `framework/governance/ID_NAMING_STANDARDS.md`

**Common ID Formats**:
- **Planning Documents**: `PLAN-NNN` (e.g., PLAN-01, PLAN-02)
- **Requirements**: `REQ-NN` or `REQ-NN-YY` (e.g., REQ-01, REQ-01-01)
- **Tasks**: `TASK-NNN` or `TASK-NNN-YY` (e.g., TASK-01, TASK-01-01)

**Format Rules**:
- Use TYPE-NN for primary documents (three digits with leading zeros)
- Use TYPE-NN-YY for sub-items (two digits with leading zeros)
- IDs are unique within their artifact type
- Sequential numbering starts at 001

---

## MVP/MMP/MMR Framework

### Definitions (2024-2025 Best Practices)

#### MVP (Minimum Viable Product)
**Purpose**: Learning vehicle to validate core hypothesis with early adopters
**Focus**: Test riskiest assumptions, gather feedback, prove feasibility
**Quality**: Can have bugs, imperfect UX, manual processes
**Goal**: Answer "Can we build this?" and "Will users use it?"
**Monetization**: Not required - learning, not earning
**Timeline**: 4-12 weeks typical

**MVP Success Criteria**:
- Core functionality works end-to-end
- Riskiest technical assumptions validated
- User feedback collected
- Product-market fit signals observed

#### MMP (Minimum Marketable Product)
**Purpose**: First release-ready product that delivers real customer value
**Focus**: Market-ready quality, essential features, can be sold/deployed
**Quality**: Polished UX, stable, production-ready, minimal bugs
**Goal**: Answer "Will customers pay for this?" and "Can we support it at scale?"
**Monetization**: Required - ready for paying customers
**Timeline**: 8-20 weeks after MVP

**MMP Success Criteria**:
- All essential features complete
- Production-quality code and UX
- Security, performance, reliability validated
- Support processes in place
- Marketing/sales materials ready

#### MMR (Minimum Marketable Release)
**Purpose**: Incremental feature releases that enhance market appeal post-MMP
**Focus**: Additional features, optimizations, integrations, scale improvements
**Quality**: Same as MMP - production-ready, market-quality
**Goal**: Answer "How do we grow adoption?" and "What drives retention?"
**Monetization**: Drives expansion revenue, reduces churn, attracts new segments
**Timeline**: 2-8 weeks per release (ongoing)

**MMR Success Criteria**:
- Adds measurable customer value
- Maintains product quality standards
- Fits within product roadmap vision
- Data-driven prioritization

### Progression Path

```
IDEA → MVP (validate) → MMP (launch) → MMR-1 → MMR-2 → MMR-n (grow)
         ↓                ↓              ↓        ↓        ↓
      Learn First     Earn First    Expand Value Stream
```

### Quality Gates

| Stage | Testing | Documentation | UX | Performance | Security |
|-------|---------|---------------|-----|-------------|----------|
| MVP | Manual OK | Minimal | Basic | Good enough | Basic |
| MMP | Automated | Complete | Polished | Production SLA | Full audit |
| MMR | Automated | Updated | Polished | Production SLA | Continuous |


---

## Analysis Methodology

Follow these 6 steps to create any implementation plan:

### Step 1: Requirements Discovery

**Objective**: Catalog all requirements and understand project scope

**Process**:
1. Read all requirement documents (BRD, PRD, user stories)
2. Extract for each requirement:
   - ID, Description, Complexity (1-5), Priority hints, Dependencies, Functional area
3. Create requirement inventory table

**Output**: Complete catalog of all requirements

### Step 2: Dependency Mapping

**Objective**: Identify relationships and sequencing constraints

**Dependency Types**:
- Technical: Requires infrastructure/library/component
- Business: Prerequisite functionality for workflow
- Data: Requires schema/migration/data source
- Integration: Depends on external system/API

**Process**:
1. For each requirement, identify dependencies
2. Classify as blocking or non-blocking
3. Create dependency graph
4. Identify critical path

**Output**: Dependency map showing blocking relationships

### Step 3: Atomic Grouping Principles

**Objective**: Create independently deployable, testable groups

**Atomic Group Characteristics**:
- Cohesive: Related functionality together
- Independent: Can be developed/tested/deployed separately
- Testable: Clear acceptance criteria
- Valuable: Delivers observable outcome
- Sized Right: 1-4 weeks of work

**Grouping Techniques**:
1. Functional Cohesion: Group by feature area
2. Technical Layer: Group by architectural component
3. User Journey: Group by end-to-end workflow
4. Dependency Cluster: Group tightly coupled requirements

**Naming Convention**: "[Component] [Action]" (e.g., "Broker Integration", "Risk Validation Framework")

**Output**: List of atomic groups with clear boundaries

### Step 4: Stage Assignment (MVP/MMP/MMR)

**Decision Framework**:

MVP Assignment Criteria (must meet at least 2):
- Validates core technical feasibility
- Required for end-to-end workflow
- Tests riskiest assumption
- Generates critical user feedback
- No viable workaround exists

MMP Assignment Criteria:
- Essential for first customer/user
- Required for production deployment
- Regulatory/compliance necessity
- Security/reliability/data integrity critical
- Competitive table stakes feature

MMR Assignment Criteria:
- Enhances existing functionality
- Expands market reach or use cases
- Optimization or performance improvement
- Integration with optional systems
- Nice-to-have that drives adoption/retention

**Output**: Each atomic group assigned to MVP, MMP, MMR-1, MMR-2, etc.

### Step 5: Priority Numbering

**Priority Numbering System**:
- Sequential priorities (1, 2, 3...): Must complete in order
- Parallel priorities (same number): Can execute simultaneously

**Prioritization Rules**:
1. Dependency-Driven: Higher priority = fewer dependencies
2. Risk-First: Address high-risk/uncertainty early
3. Value-Weighed: Balance technical dependencies with business value
4. Resource-Aware: Consider team size and skill distribution

**Parallelization Check**:
- No technical dependencies?
- Different code areas?
- Separate team members available?
- No shared infrastructure bottleneck?
- Integration points clearly defined?

If all yes → Assign same priority number

**Output**: Priority-numbered atomic groups

### Step 6: Timeline Estimation

**Complexity-Based Estimation**:
- Complexity 1: 0.5-1 week
- Complexity 2: 1-2 weeks
- Complexity 3: 2-3 weeks
- Complexity 4: 3-4 weeks
- Complexity 5: 4-6 weeks

**Buffer Management**:
- Stage level: +15% buffer
- Project level: +25% buffer

**Timeline Formula**:
```
Total Time = Σ(Group Duration) / Parallel Tracks + Stage Buffers
```

**Output**: Gantt chart with start/end dates and milestones

---

## Progress Tracking & Status Management

### Implementation Status Categories

| Status | Symbol | Meaning | Mutability |
|--------|--------|---------|------------|
| COMPLETED | ✅ | Fully implemen