Initial commit
This commit is contained in:
Zhongwei Li
684
skills/dependency-analysis/examples.md
Normal file
684
skills/dependency-analysis/examples.md
Normal file
@@ -0,0 +1,684 @@
|
||||
# Dependency Analysis Skill - Usage Examples
|
||||
|
||||
## Example 1: Feature Appears Stalled
|
||||
|
||||
### Scenario
|
||||
Developer notices that a feature with 8 tasks has been "in development" for 2 weeks, but only 2 tasks are complete. They want to understand what's blocking progress.
|
||||
|
||||
### User Query
|
||||
> "The authentication feature seems stuck. What's blocking us?"
|
||||
|
||||
### Skill Execution
|
||||
|
||||
**Step 1**: Get feature ID from context or search
|
||||
```javascript
|
||||
search_features(name="authentication")
|
||||
// Returns: featureId = "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
|
||||
```
|
||||
|
||||
**Step 2**: Find blocked tasks
|
||||
```javascript
|
||||
get_blocked_tasks(featureId="a1b2c3d4-e5f6-7890-abcd-ef1234567890")
|
||||
```
|
||||
|
||||
**Response Data**:
|
||||
```json
|
||||
{
|
||||
"blockedTasks": [
|
||||
{
|
||||
"id": "task-1",
|
||||
"title": "Implement login UI",
|
||||
"blockedBy": ["task-api"]
|
||||
},
|
||||
{
|
||||
"id": "task-2",
|
||||
"title": "Add logout functionality",
|
||||
"blockedBy": ["task-api"]
|
||||
},
|
||||
{
|
||||
"id": "task-3",
|
||||
"title": "Implement password reset",
|
||||
"blockedBy": ["task-api", "task-1"]
|
||||
},
|
||||
{
|
||||
"id": "task-4",
|
||||
"title": "Add session management",
|
||||
"blockedBy": ["task-api"]
|
||||
}
|
||||
]
|
||||
}
|
||||
```
|
||||
|
||||
**Step 3**: Analyze blocking dependencies
|
||||
```javascript
|
||||
get_task(id="task-api", includeSections=false)
|
||||
```
|
||||
|
||||
**Response**:
|
||||
```json
|
||||
{
|
||||
"id": "task-api",
|
||||
"title": "Create authentication API endpoints",
|
||||
"status": "in_progress",
|
||||
"priority": "high",
|
||||
"complexity": 7,
|
||||
"assignedTo": "Backend Engineer"
|
||||
}
|
||||
```
|
||||
|
||||
### Skill Response
|
||||
```
|
||||
Found 4 blocked tasks (50% of remaining work) in "Authentication Feature":
|
||||
|
||||
Root Cause: "Create authentication API endpoints" (in-progress) is blocking 4 tasks:
|
||||
- Implement login UI
|
||||
- Add logout functionality
|
||||
- Implement password reset
|
||||
- Add session management
|
||||
|
||||
Current Status: API task is in-progress (complexity: 7/10)
|
||||
|
||||
Recommendation:
|
||||
1. Prioritize completing the API task (unblocks 4 tasks)
|
||||
2. Once API is done, "Implement login UI" should be next (it blocks password reset)
|
||||
3. After that, 3 tasks can proceed in parallel
|
||||
|
||||
Estimated Impact: Completing API task will unblock 50% of remaining feature work.
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Example 2: Planning Parallel Work Across Team
|
||||
|
||||
### Scenario
|
||||
Team has 5 developers available. Project manager wants to maximize parallel work by identifying tasks with no dependencies.
|
||||
|
||||
### User Query
|
||||
> "We have 5 developers ready to work. What tasks can they start in parallel?"
|
||||
|
||||
### Skill Execution
|
||||
|
||||
**Step 1**: Get all pending tasks with no dependencies
|
||||
```javascript
|
||||
search_tasks(projectId="project-id", status="pending")
|
||||
// Filter to tasks where dependsOn is empty
|
||||
```
|
||||
|
||||
**Step 2**: For each task, verify no incomplete dependencies
|
||||
```javascript
|
||||
get_task_dependencies(taskId="task-x")
|
||||
// Repeat for all pending tasks
|
||||
```
|
||||
|
||||
**Step 3**: Group by specialist type (from tags)
|
||||
|
||||
### Response Data
|
||||
```
|
||||
Tasks Ready to Start (No Dependencies):
|
||||
|
||||
Backend Engineer:
|
||||
- "Implement user service API" (complexity: 6, priority: high)
|
||||
- "Add logging infrastructure" (complexity: 4, priority: medium)
|
||||
|
||||
Frontend Engineer:
|
||||
- "Create dashboard layout" (complexity: 5, priority: high)
|
||||
- "Design error page components" (complexity: 3, priority: low)
|
||||
|
||||
Database Engineer:
|
||||
- "Add database indexes" (complexity: 5, priority: medium)
|
||||
|
||||
Test Engineer:
|
||||
- "Setup integration test framework" (complexity: 6, priority: high)
|
||||
|
||||
Documentation:
|
||||
- "Write API documentation template" (complexity: 2, priority: medium)
|
||||
```
|
||||
|
||||
### Skill Response
|
||||
```
|
||||
7 tasks are ready to start with no dependencies:
|
||||
|
||||
Parallel Work Assignment (5 developers):
|
||||
|
||||
Priority 1 (High Priority, Start Immediately):
|
||||
- Backend: "Implement user service API" (complexity: 6/10)
|
||||
- Frontend: "Create dashboard layout" (complexity: 5/10)
|
||||
- Database: "Add database indexes" (complexity: 5/10)
|
||||
- Test: "Setup integration test framework" (complexity: 6/10)
|
||||
|
||||
Priority 2 (After completing Priority 1):
|
||||
- Backend: "Add logging infrastructure" (complexity: 4/10)
|
||||
- Docs: "Write API documentation template" (complexity: 2/10)
|
||||
|
||||
Priority 3 (Lower Priority):
|
||||
- Frontend: "Design error page components" (complexity: 3/10)
|
||||
|
||||
Recommendation: Start 4 developers on Priority 1 tasks, assign 5th developer to Priority 2 task. All can proceed in parallel without coordination.
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Example 3: Investigating Circular Dependencies
|
||||
|
||||
### Scenario
|
||||
Developer tries to mark a task complete but gets an error about circular dependencies. They need to understand and fix the issue.
|
||||
|
||||
### User Query
|
||||
> "I'm getting a circular dependency error with task T5. What's wrong?"
|
||||
|
||||
### Skill Execution
|
||||
|
||||
**Step 1**: Get dependency chain for task
|
||||
```javascript
|
||||
get_task_dependencies(taskId="T5", includeTransitive=true)
|
||||
```
|
||||
|
||||
**Response**:
|
||||
```json
|
||||
{
|
||||
"dependencies": [
|
||||
{"taskId": "T4", "title": "Design user flow"},
|
||||
{"taskId": "T3", "title": "Create wireframes", "transitive": true},
|
||||
{"taskId": "T5", "title": "Implement UI", "transitive": true}
|
||||
]
|
||||
}
|
||||
```
|
||||
|
||||
**Step 2**: Trace the cycle
|
||||
```
|
||||
T5 (Implement UI)
|
||||
→ depends on T4 (Design user flow)
|
||||
→ depends on T3 (Create wireframes)
|
||||
→ depends on T5 (Implement UI) ← CYCLE DETECTED
|
||||
```
|
||||
|
||||
### Skill Response
|
||||
```
|
||||
⚠️ Circular Dependency Detected:
|
||||
|
||||
Dependency Cycle:
|
||||
T5 "Implement UI"
|
||||
→ T4 "Design user flow"
|
||||
→ T3 "Create wireframes"
|
||||
→ T5 "Implement UI" (cycle back to start)
|
||||
|
||||
Problem: These tasks depend on each other in a loop, creating a deadlock where none can be started.
|
||||
|
||||
Root Cause Analysis:
|
||||
- T5 depends on T4: UI implementation needs finalized design
|
||||
- T4 depends on T3: Design needs wireframes
|
||||
- T3 depends on T5: Wireframes need to see existing UI (INCORRECT)
|
||||
|
||||
Solution: Remove the T3→T5 dependency. Wireframes should inform UI implementation, not depend on it.
|
||||
|
||||
Recommended Fix:
|
||||
1. Remove dependency: T3 → T5
|
||||
2. Correct sequence: T3 (wireframes) → T4 (design) → T5 (implement)
|
||||
|
||||
This creates a linear dependency chain with no cycles.
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Example 4: Finding Critical Path for Release
|
||||
|
||||
### Scenario
|
||||
Product manager needs to know the minimum time to complete a feature, assuming unlimited resources. Need to find the longest dependency chain (critical path).
|
||||
|
||||
### User Query
|
||||
> "What's the fastest we can ship the payment integration feature?"
|
||||
|
||||
### Skill Execution
|
||||
|
||||
**Step 1**: Get all tasks in feature
|
||||
```javascript
|
||||
search_tasks(featureId="payment-feature-id")
|
||||
```
|
||||
|
||||
**Step 2**: Build complete dependency graph
|
||||
```javascript
|
||||
// For each task, get dependencies
|
||||
get_task_dependencies(taskId="task-x", includeTransitive=true)
|
||||
```
|
||||
|
||||
**Step 3**: Calculate critical path (longest chain)
|
||||
|
||||
### Dependency Graph
|
||||
```
|
||||
Tasks and Dependencies:
|
||||
|
||||
T1: Setup Stripe account (no dependencies) - 1 day
|
||||
T2: Implement payment API (depends on T1) - 3 days
|
||||
T3: Create payment UI (depends on T2) - 2 days
|
||||
T4: Add error handling (depends on T2) - 1 day
|
||||
T5: Write integration tests (depends on T3, T4) - 2 days
|
||||
T6: Deploy to staging (depends on T5) - 1 day
|
||||
|
||||
Parallel paths:
|
||||
Path A: T1 → T2 → T3 → T5 → T6 = 9 days
|
||||
Path B: T1 → T2 → T4 → T5 → T6 = 8 days
|
||||
```
|
||||
|
||||
### Skill Response
|
||||
```
|
||||
Critical Path Analysis for "Payment Integration Feature":
|
||||
|
||||
Longest dependency chain: 5 tasks, 9 days total
|
||||
Critical Path: T1 → T2 → T3 → T5 → T6
|
||||
|
||||
Task Sequence (must complete in order):
|
||||
1. T1: Setup Stripe account (1 day, complexity: 3/10)
|
||||
2. T2: Implement payment API (3 days, complexity: 7/10) ← BOTTLENECK
|
||||
3. T3: Create payment UI (2 days, complexity: 5/10)
|
||||
4. T5: Write integration tests (2 days, complexity: 6/10)
|
||||
5. T6: Deploy to staging (1 day, complexity: 4/10)
|
||||
|
||||
Parallel Opportunity:
|
||||
- T4 "Add error handling" (1 day) can run in parallel with T3
|
||||
- Assign to different developer to save 1 day
|
||||
|
||||
Optimized Timeline:
|
||||
- Sequential: 9 days (one developer)
|
||||
- With parallel work: 8 days (two developers)
|
||||
|
||||
Recommendation: Prioritize T2 (API) as it's the most complex and blocks all downstream work.
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Example 5: Prioritizing Bug Fixes with Dependencies
|
||||
|
||||
### Scenario
|
||||
Multiple bugs reported, some bugs are blocking work on new features. Need to prioritize which bugs to fix first.
|
||||
|
||||
### User Query
|
||||
> "We have 8 bugs and 12 feature tasks. Which bugs should we fix first?"
|
||||
|
||||
### Skill Execution
|
||||
|
||||
**Step 1**: Get all blocked feature tasks
|
||||
```javascript
|
||||
get_blocked_tasks(projectId="project-id")
|
||||
```
|
||||
|
||||
**Step 2**: Identify bug tasks blocking features
|
||||
```javascript
|
||||
// Filter blockedBy tasks where tags include "bug"
|
||||
search_tasks(tags="bug", status="pending,in_progress")
|
||||
```
|
||||
|
||||
**Step 3**: Count how many tasks each bug is blocking
|
||||
|
||||
### Analysis Result
|
||||
```
|
||||
Bug Impact Analysis:
|
||||
|
||||
High Impact Bugs (blocking multiple tasks):
|
||||
- Bug #42 "API returns 500 on invalid input" → Blocking 5 feature tasks
|
||||
Status: pending, Complexity: 4/10, Priority: critical
|
||||
|
||||
- Bug #38 "Database migration fails on fresh install" → Blocking 3 feature tasks
|
||||
Status: in_progress, Complexity: 6/10, Priority: high
|
||||
|
||||
Medium Impact Bugs (blocking 1-2 tasks):
|
||||
- Bug #51 "Login session expires too quickly" → Blocking 2 tasks
|
||||
Status: pending, Complexity: 3/10, Priority: medium
|
||||
|
||||
Low Impact Bugs (not blocking features):
|
||||
- Bug #22, #33, #45, #49, #50 → Not blocking any tasks
|
||||
Priority: low to medium
|
||||
```
|
||||
|
||||
### Skill Response
|
||||
```
|
||||
Bug Fix Priority for Maximum Feature Unblocking:
|
||||
|
||||
URGENT (Fix Immediately):
|
||||
1. Bug #42 "API returns 500 on invalid input"
|
||||
- Blocking: 5 feature tasks
|
||||
- Complexity: 4/10 (relatively easy)
|
||||
- Impact Score: 58/100 (high impact, easy fix)
|
||||
- Estimated Time: 2-3 hours
|
||||
- Recommendation: Fix first, unblocks most work
|
||||
|
||||
2. Bug #38 "Database migration fails" (in-progress)
|
||||
- Blocking: 3 feature tasks
|
||||
- Complexity: 6/10
|
||||
- Impact Score: 39/100
|
||||
- Status: Already being worked on
|
||||
|
||||
MEDIUM PRIORITY (Fix Soon):
|
||||
3. Bug #51 "Session expires too quickly"
|
||||
- Blocking: 2 feature tasks
|
||||
- Complexity: 3/10
|
||||
- Impact Score: 32/100
|
||||
|
||||
LOW PRIORITY (Fix After Features):
|
||||
- Bugs #22, #33, #45, #49, #50
|
||||
- Not blocking any work
|
||||
- Schedule after feature tasks complete
|
||||
|
||||
Impact if prioritized correctly:
|
||||
- Fixing Bug #42 → Unblocks 5 tasks (4 hours of feature work available)
|
||||
- Fixing Bug #38 → Unblocks 3 more tasks
|
||||
- Total: 8 tasks unblocked (66% of blocked work)
|
||||
|
||||
Recommendation: Assign 1 developer to Bug #42 immediately (2-3 hours to unblock 5 tasks). Continue Bug #38 work. Defer low-priority bugs.
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Example 6: Sprint Planning - Maximizing Velocity
|
||||
|
||||
### Scenario
|
||||
Scrum master planning 2-week sprint. Want to maximize completed tasks by intelligently ordering work based on dependencies.
|
||||
|
||||
### User Query
|
||||
> "Help me plan the sprint. We have 2 weeks and 4 developers. What order should we tackle tasks?"
|
||||
|
||||
### Skill Execution
|
||||
|
||||
**Step 1**: Get all tasks ready for sprint
|
||||
```javascript
|
||||
search_tasks(projectId="project-id", status="pending")
|
||||
```
|
||||
|
||||
**Step 2**: Analyze dependencies and bottlenecks
|
||||
```javascript
|
||||
get_blocked_tasks(projectId="project-id")
|
||||
// For each task: get_task_dependencies(taskId="x")
|
||||
```
|
||||
|
||||
**Step 3**: Calculate optimal task ordering
|
||||
|
||||
### Analysis
|
||||
```
|
||||
Available Tasks: 20 pending tasks
|
||||
Sprint Capacity: 4 developers × 10 days = 40 developer-days
|
||||
Average task: 2-3 days
|
||||
|
||||
Dependency Analysis:
|
||||
- 8 tasks have no dependencies (ready to start)
|
||||
- 7 tasks have 1 dependency each
|
||||
- 5 tasks have 2+ dependencies
|
||||
|
||||
Bottleneck Tasks (blocking multiple):
|
||||
- T2 "Setup CI pipeline" → Blocks 4 tasks
|
||||
- T5 "Create database schema" → Blocks 6 tasks
|
||||
```
|
||||
|
||||
### Skill Response
|
||||
```
|
||||
Sprint Plan - 2 Weeks, 4 Developers:
|
||||
|
||||
Week 1 Strategy: Eliminate Bottlenecks
|
||||
|
||||
Monday-Tuesday (Days 1-2):
|
||||
- Dev 1: T5 "Create database schema" (2 days, unblocks 6 tasks)
|
||||
- Dev 2: T2 "Setup CI pipeline" (2 days, unblocks 4 tasks)
|
||||
- Dev 3: T8 "Implement auth service" (3 days, no dependencies)
|
||||
- Dev 4: T12 "Design homepage" (2 days, no dependencies)
|
||||
|
||||
Wednesday-Friday (Days 3-5):
|
||||
After T5 completes, 6 new tasks become available
|
||||
After T2 completes, 4 new tasks become available
|
||||
|
||||
- Dev 1: T15 "Add user CRUD" (depends on T5, now ready)
|
||||
- Dev 2: T20 "Setup automated tests" (depends on T2, now ready)
|
||||
- Dev 3: T8 continues (1 day left)
|
||||
- Dev 4: T13 "Build component library" (2 days)
|
||||
|
||||
Week 2 Strategy: Parallel Execution
|
||||
|
||||
Monday-Friday (Days 6-10):
|
||||
With bottlenecks cleared, 10 tasks now have no dependencies:
|
||||
- All 4 developers can work in parallel
|
||||
- No coordination overhead
|
||||
- Maximum velocity
|
||||
|
||||
Projected Sprint Completion:
|
||||
- Week 1: 6 tasks complete (focusing on bottlenecks)
|
||||
- Week 2: 10-12 tasks complete (parallel work)
|
||||
- Total: 16-18 tasks (80-90% of sprint backlog)
|
||||
|
||||
Key Insight: Prioritizing bottleneck tasks (T2, T5) in Week 1 unlocks maximum parallel work in Week 2.
|
||||
|
||||
Alternative Approach (Not Recommended):
|
||||
If we ignore dependencies and just pick tasks randomly:
|
||||
- Week 1: Complete 6 tasks, but 12 tasks still blocked
|
||||
- Week 2: Only 2 tasks available (both developers wait)
|
||||
- Total: 8 tasks complete (40% of sprint backlog)
|
||||
|
||||
Recommendation: Follow the suggested ordering to maximize sprint velocity.
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Example 7: Debugging "Why Can't I Start This Task?"
|
||||
|
||||
### Scenario
|
||||
Developer assigned to task, but unclear why they can't start yet. Need to trace back through dependency chain.
|
||||
|
||||
### User Query
|
||||
> "I'm assigned to 'Add payment webhooks' but it says dependencies aren't met. What am I waiting for?"
|
||||
|
||||
### Skill Execution
|
||||
|
||||
**Step 1**: Get the task with dependencies
|
||||
```javascript
|
||||
get_task(id="webhook-task-id", includeDependencies=true)
|
||||
```
|
||||
|
||||
**Step 2**: Trace dependency chain
|
||||
```javascript
|
||||
get_task_dependencies(taskId="webhook-task-id", includeTransitive=true)
|
||||
```
|
||||
|
||||
### Response Data
|
||||
```json
|
||||
{
|
||||
"task": {
|
||||
"id": "webhook-task-id",
|
||||
"title": "Add payment webhooks",
|
||||
"status": "pending"
|
||||
},
|
||||
"dependencies": [
|
||||
{
|
||||
"taskId": "T12",
|
||||
"title": "Implement payment processing",
|
||||
"status": "in_progress",
|
||||
"dependsOn": ["T9", "T10"]
|
||||
}
|
||||
],
|
||||
"transitiveDependencies": [
|
||||
{
|
||||
"taskId": "T9",
|
||||
"title": "Setup Stripe integration",
|
||||
"status": "completed"
|
||||
},
|
||||
{
|
||||
"taskId": "T10",
|
||||
"title": "Create payment database tables",
|
||||
"status": "in_progress"
|
||||
}
|
||||
]
|
||||
}
|
||||
```
|
||||
|
||||
### Skill Response
|
||||
```
|
||||
Dependency Trace for "Add payment webhooks":
|
||||
|
||||
You are blocked by: T12 "Implement payment processing" (in-progress)
|
||||
|
||||
Full Dependency Chain:
|
||||
[Your Task] "Add payment webhooks"
|
||||
← T12 "Implement payment processing" (in-progress) ← YOU ARE HERE
|
||||
← T9 "Setup Stripe integration" (completed) ✓
|
||||
← T10 "Create payment database tables" (in-progress) ← ROOT CAUSE
|
||||
|
||||
Root Cause: T10 "Create payment database tables" is still in progress
|
||||
- T10 is being worked on by Database Engineer
|
||||
- Once T10 completes, T12 can finish
|
||||
- Once T12 completes, you can start your task
|
||||
|
||||
Current Status:
|
||||
- T9: ✓ Completed
|
||||
- T10: ⏳ In-progress (blocks T12)
|
||||
- T12: ⏳ In-progress (blocks your task)
|
||||
|
||||
Estimated Timeline:
|
||||
- T10 completion: Expected in 1-2 days
|
||||
- T12 completion: Expected 2 days after T10
|
||||
- Your task ready: ~3-4 days from now
|
||||
|
||||
What You Can Do Now:
|
||||
1. Review T12 "Implement payment processing" code to prepare
|
||||
2. Read Stripe webhook documentation
|
||||
3. Design webhook handling strategy
|
||||
4. Write unit tests (can start before implementation)
|
||||
5. Check if there are other tasks you can help with
|
||||
|
||||
Would you like me to find other tasks you can work on while waiting?
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Example 8: Quarterly Planning - Long-term Dependencies
|
||||
|
||||
### Scenario
|
||||
Engineering manager planning Q4 roadmap. Need to understand high-level dependencies across multiple features.
|
||||
|
||||
### User Query
|
||||
> "Show me the dependency relationships between our Q4 features"
|
||||
|
||||
### Skill Execution
|
||||
|
||||
**Step 1**: Get all features in project
|
||||
```javascript
|
||||
search_features(projectId="project-id")
|
||||
```
|
||||
|
||||
**Step 2**: For each feature, analyze task dependencies
|
||||
```javascript
|
||||
// Identify cross-feature dependencies
|
||||
```
|
||||
|
||||
### Feature Dependency Map
|
||||
```
|
||||
Q4 Features (4 total):
|
||||
|
||||
F1: User Authentication (8 tasks)
|
||||
├─ No external dependencies
|
||||
└─ Blocks: F2, F3, F4
|
||||
|
||||
F2: User Dashboard (12 tasks)
|
||||
├─ Depends on: F1 (auth required)
|
||||
└─ Blocks: F4 (dashboard needed for settings)
|
||||
|
||||
F3: Payment Integration (10 tasks)
|
||||
├─ Depends on: F1 (auth required for payments)
|
||||
└─ Independent from F2, F4
|
||||
|
||||
F4: User Settings (6 tasks)
|
||||
├─ Depends on: F1 (auth), F2 (dashboard layout)
|
||||
└─ No downstream dependencies
|
||||
```
|
||||
|
||||
### Skill Response
|
||||
```
|
||||
Q4 Feature Dependency Analysis:
|
||||
|
||||
Critical Path: F1 → F2 → F4
|
||||
- Must complete sequentially
|
||||
- Total: 26 tasks across 3 features
|
||||
- Estimated: 8-10 weeks
|
||||
|
||||
Parallel Opportunity: F3 (Payment Integration)
|
||||
- Only depends on F1 (auth)
|
||||
- Can proceed in parallel with F2
|
||||
- 10 tasks, estimated: 4 weeks
|
||||
|
||||
Recommended Q4 Schedule:
|
||||
|
||||
Weeks 1-3: Feature F1 "User Authentication"
|
||||
- Critical foundation for all other features
|
||||
- 8 tasks, complexity: medium-high
|
||||
- Must complete first (blocks everything)
|
||||
|
||||
Weeks 4-7: Features F2 + F3 in parallel
|
||||
- F2 "User Dashboard" (12 tasks) ← Team A
|
||||
- F3 "Payment Integration" (10 tasks) ← Team B
|
||||
- Both can proceed simultaneously after F1
|
||||
|
||||
Weeks 8-10: Feature F4 "User Settings"
|
||||
- Depends on F1 + F2 completing
|
||||
- 6 tasks, complexity: low-medium
|
||||
- Can start once F2 completes
|
||||
|
||||
Bottleneck Analysis:
|
||||
⚠️ F1 is a critical bottleneck - it blocks ALL other Q4 work
|
||||
- Risk: If F1 slips, entire Q4 roadmap delays
|
||||
- Mitigation: Prioritize F1, assign best team, add buffer time
|
||||
|
||||
Velocity Optimization:
|
||||
- Sequential only: 16-18 weeks (F1→F2→F3→F4)
|
||||
- With parallelization: 10-12 weeks (F1→[F2+F3]→F4)
|
||||
- Time savings: 6 weeks (37% faster)
|
||||
|
||||
Recommendation:
|
||||
1. Over-invest in F1 (critical path blocker)
|
||||
2. Split teams after F1 to parallelize F2 + F3
|
||||
3. Build buffer time into F1 estimate
|
||||
4. Consider soft-launching F3 before F4 (independent feature)
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Key Takeaways from Examples
|
||||
|
||||
### Pattern Recognition
|
||||
|
||||
**When user asks about**:
|
||||
- "What's blocking..." → Run `get_blocked_tasks`
|
||||
- "Can we work in parallel..." → Find tasks with no dependencies
|
||||
- "Circular dependency" → Trace dependency chain
|
||||
- "Fastest timeline" → Calculate critical path
|
||||
- "What should we prioritize" → Analyze bottlenecks + impact
|
||||
|
||||
### Response Quality
|
||||
|
||||
**Good responses include**:
|
||||
1. Clear identification of the problem
|
||||
2. Root cause analysis (why the blockage exists)
|
||||
3. Quantified impact (tasks blocked, time saved)
|
||||
4. Actionable recommendations (specific next steps)
|
||||
5. Alternative approaches when applicable
|
||||
|
||||
### Tool Combinations
|
||||
|
||||
**Most analyses require**:
|
||||
- `get_blocked_tasks` - Find what's blocked
|
||||
- `get_task_dependencies` - Understand why
|
||||
- `get_task` - Get task details (priority, complexity)
|
||||
- `search_tasks` - Find patterns across multiple tasks
|
||||
|
||||
**Power combo**:
|
||||
```javascript
|
||||
// 1. Find blocked tasks
|
||||
blockedTasks = get_blocked_tasks(featureId=X)
|
||||
|
||||
// 2. For each blocker, count impact
|
||||
for each blocker:
|
||||
impactCount = count(tasks where blockedBy contains blocker)
|
||||
|
||||
// 3. Get blocker details
|
||||
blockerDetails = get_task(id=blocker)
|
||||
|
||||
// 4. Calculate priority score
|
||||
score = (impactCount × 10) + (priority × 5) - (complexity × 2)
|
||||
|
||||
// 5. Recommend highest score task
|
||||
```
|
||||
|
||||
This pattern appears in Examples 1, 4, 5, and 6.
|
||||
Reference in New Issue
Block a user