## Project Planning Framework
### Phase 1: Vision & Scope Definition
```
Define project vision and scope for:
**Project Idea:** [Brief description]
**Stakeholders:** [Who has interest in this]
**Budget/Timeline Constraints:** [Any known limits]
Vision definition:
1. **Problem Statement**
- What problem does this solve?
- Who experiences this problem?
- How are they solving it today?
- Why is a new solution needed?
2. **Success Criteria**
- How will we know if this succeeds?
- What metrics will we track?
- What's the minimum viable outcome?
- What's the ideal outcome?
3. **Scope Definition**
- What's IN scope?
- What's explicitly OUT of scope?
- What's TBD/future consideration?
- What are the non-negotiable requirements?
4. **Assumptions & Dependencies**
- What are we assuming to be true?
- What external dependencies exist?
- What decisions need to be made?
Generate project vision document.
```
### Phase 2: Requirements Gathering
```
Gather requirements for:
**Project:** [Name]
**Users:** [Primary user types]
Requirements framework:
1. **User Stories**
```
As a [user type]
I want to [action]
So that [benefit]
Acceptance Criteria:
- Given [context]
- When [action]
- Then [expected result]
```
2. **Functional Requirements**
| ID | Requirement | Priority | Complexity |
|----|-------------|----------|------------|
| FR-001 | User authentication | Must | Medium |
| FR-002 | ... | Should | ... |
3. **Non-Functional Requirements**
- Performance: [Response time, throughput]
- Scalability: [Users, data volume]
- Availability: [Uptime SLA]
- Security: [Authentication, encryption]
- Accessibility: [WCAG level]
4. **Technical Requirements**
- Platforms: [Web, mobile, desktop]
- Integrations: [APIs, services]
- Data: [Storage, privacy]
- Infrastructure: [Cloud, on-prem]
5. **MoSCoW Prioritization**
- **Must Have:** Core functionality (MVP)
- **Should Have:** Important but not critical
- **Could Have:** Nice to have
- **Won't Have:** Explicitly out of scope
Generate prioritized requirements backlog.
```
### Phase 3: Timeline & Estimation
```
Estimate timeline for:
**Project:** [Name]
**Team Size:** [Number and roles]
**Requirements:** [Number of must/should/could items]
Estimation approach:
1. **Work Breakdown Structure**
```
Project
├── Phase 1: Foundation (Weeks 1-2)
│ ├── Tech stack setup
│ ├── CI/CD pipeline
│ └── Core architecture
├── Phase 2: Core Features (Weeks 3-6)
│ ├── Feature A
│ ├── Feature B
│ └── Feature C
├── Phase 3: Polish (Weeks 7-8)
│ ├── Testing
│ ├── Bug fixes
│ └── Documentation
└── Phase 4: Launch (Week 9)
├── Deployment
└── Monitoring
```
2. **Estimation Techniques**
- T-shirt sizing: XS, S, M, L, XL
- Story points: Fibonacci (1, 2, 3, 5, 8, 13)
- Time-based: Convert to hours/days
**Estimation formula:**
Realistic = (Optimistic + 4×Most Likely + Pessimistic) / 6
Add 20-30% buffer for unknowns
3. **Velocity Assumptions**
- New team: 60-70% of ideal velocity
- Established team: 80-90%
- Account for meetings, reviews, context switching
4. **Milestone Definition**
| Milestone | Date | Deliverables | Success Criteria |
|-----------|------|--------------|------------------|
| Alpha | Week 4 | Core features | Internal demo |
| Beta | Week 7 | All features | User testing |
| Launch | Week 9 | Production | GA release |
Generate project timeline with Gantt chart.
```
### Phase 4: Risk Assessment
```
Assess risks for:
**Project:** [Name]
**Timeline:** [Duration]
**Team:** [Size and experience]
Risk matrix:
1. **Risk Identification**
| Risk | Category | Probability | Impact |
|------|----------|-------------|--------|
| Key developer leaves | People | Medium | High |
| Scope creep | Process | High | Medium |
| Integration delays | Technical | Medium | High |
| Budget overrun | Financial | Low | High |
2. **Risk Scoring**
```
Score = Probability × Impact
5×5 Matrix:
│ Low │ Med │ High│ Crit│
─────┼─────┼─────┼─────┼─────┤
High │ 5 │ 10 │ 15 │ 20 │ ← Probability
Med │ 3 │ 6 │ 9 │ 12 │
Low │ 1 │ 2 │ 3 │ 4 │
None │ 0 │ 0 │ 0 │ 0 │
```
3. **Mitigation Strategies**
For each high-priority risk:
- Prevention: How to reduce probability
- Mitigation: How to reduce impact
- Contingency: What to do if it happens
- Owner: Who monitors this risk
4. **Risk Register**
Maintain ongoing with:
- Status (Open, Mitigated, Occurred, Closed)
- Last review date
- Trigger indicators
- Escalation path
Generate risk register and mitigation plan.
```
### Phase 5: Resource Planning
```
Plan resources for:
**Project:** [Name]
**Duration:** [Weeks/months]
**Budget:** [If known]
Resource allocation:
1. **Team Composition**
| Role | Count | Allocation | Duration |
|------|-------|------------|----------|
| Tech Lead | 1 | 100% | Full project |
| Frontend Dev | 2 | 100% | Weeks 2-8 |
| Backend Dev | 2 | 100% | Weeks 1-8 |
| Designer | 1 | 50% | Weeks 1-4 |
| QA | 1 | 50% | Weeks 5-9 |
2. **Skills Matrix**
| Skill | Required | Available | Gap |
|-------|----------|-----------|-----|
| React | 2 devs | 2 devs | ✓ |
| K8s | 1 dev | 0 devs | Hire/train |
3. **Infrastructure & Tools**
- Cloud services: [AWS/GCP/Azure]
- Development tools: [IDE, design tools]
- Third-party services: [Auth, payments]
- Estimated monthly cost: $X
4. **RACI Matrix**
| Task | Lead | Dev | PM | Stakeholder |
|------|------|-----|-------|-------------|
| Architecture | A | C | I | I |
| Sprint Planning | C | R | A | I |
| Deployment | R | R | I | I |
R=Responsible, A=Accountable, C=Consulted, I=Informed
Generate resource plan and allocation chart.
```
## Project Documentation Templates
```
Essential project documents:
1. **Project Charter** (1 page)
- Vision and objectives
- Success criteria
- Scope summary
- Key stakeholders
- High-level timeline
2. **Technical Specification**
- Architecture overview
- Data models
- API contracts
- Integration points
- Security requirements
3. **Communication Plan**
- Stakeholder matrix
- Meeting cadence
- Reporting schedule
- Escalation paths
4. **Definition of Done**
- Code complete
- Tests passing
- Code reviewed
- Documentation updated
- Deployed to staging
```
## Best Practices
1. **Start with Why**: Ensure clarity on the problem being solved
2. **Involve Stakeholders Early**: Better requirements, fewer surprises
3. **Be Realistic**: Padding estimates is not lying
4. **Document Assumptions**: Make implicit knowledge explicit
5. **Plan for Change**: Scope will evolve; design for flexibility
6. **Identify Risks Early**: What you don't know can hurt you
7. **Define Success**: Know when you've achieved the goal
8. **Communicate Constantly**: Over-communication is rarely the problem
## Example Session
**User**: "Help me plan a new e-commerce mobile app project."
**Response**:
> Here's a kickoff plan for your e-commerce mobile app:
>
> **Vision:** Enable customers to browse, purchase, and track orders from their mobile devices with a seamless experience.
>
> **MVP Scope (Must Have):**
>
> - User authentication
> - Product browsing/search
> - Shopping cart
> - Checkout with payment
> - Order tracking
>
> **Deferred (Phase 2):**
>
> - Wishlist, reviews, recommendations
> - Push notifications
> - Social login
>
> **Timeline Estimate:**
> | Phase | Duration | Deliverable |
> |-------|----------|-------------|
> | Discovery | 1 week | Requirements, designs |
> | Foundation | 2 weeks | Auth, navigation |
> | Core | 4 weeks | Browse, cart, checkout |
> | Polish | 2 weeks | Testing, fixes |
> | Launch | 1 week | App store submission |
>
> **Team:** 2 mobile devs, 1 backend dev, 1 designer, 1 QA
>
> Want me to detail the requirements or risk assessment?
## Related Resources
- [Shape Up](https://basecamp.com/shapeup) by Basecamp
- [The Mythical Man-Month](https://en.wikipedia.org/wiki/The_Mythical_Man-Month)
- [Agile Estimating and Planning](https://www.mountaingoatsoftware.com/books/agile-estimating-and-planning)
- [PMBOK Guide](https://www.pmi.org/pmbok-guide-standards)