Task Decomposition
Large tasks are intimidating. "Write business plan" sits on your list for weeks because you don't know where to start. GDT's task decomposition breaks down big tasks into concrete, actionable steps.
Why Decomposition Works
Breaking tasks down solves several problems:
- Reduces overwhelm. Small tasks are easier to start than vague projects.
- Improves estimation. "Design database schema (2 hours)" is easier to schedule than "build backend."
- Reveals dependencies. You discover what needs to happen first.
- Identifies risks. Potential blockers surface before they become problems.
Basic Usage
Ask GDT to break down any task:
You: Break down "develop a blog system"
GDT: 📋 Task Decomposition: Develop a Blog System
1. Requirements and design (2 hours)
- Define feature scope
- Design data models
- Create page mockups
2. Set up project (1 hour)
- Initialize project
- Configure dev environment
- Set up code standards
3. Implement articles (4 hours)
- Article CRUD API
- Markdown rendering
- List and detail pages
4. Implement users (3 hours)
- Registration/login
- Permission control
- Profile page
5. Implement comments (2 hours)
- Comment API
- Comment component
- Notifications
6. Deploy (1 hour)
- Configure server
- Deploy application
- Domain and SSL
⏱️ Estimated total: 13 hours
📊 Dependencies: 1 → 2 → 3,4 (parallel) → 5 → 6
⚠️ Risks:
- Need server and domain ready in advance
- Markdown rendering may need researchRisk Identification
GDT automatically flags potential problems:
You: Break down "migrate database to new server"
GDT: 📋 Task Decomposition: Migrate Database
1. Preparation
- Assess data volume and migration time (30 min)
- Prepare new server environment (1 hour)
- Create rollback plan (30 min)
2. Test migration
- Create test dataset (30 min)
- Execute test migration (1 hour)
- Verify data integrity (30 min)
3. Production migration
- Notify stakeholders of downtime (15 min)
- Create full backup (1 hour)
- Execute migration (2 hours)
- Update application config (30 min)
4. Verification
- Functional verification (30 min)
- Performance monitoring (1 hour)
- Collect feedback (ongoing)
⚠️ Risk Assessment:
🔴 High Risk: Data loss
Cause: Migration interruption or failure
Mitigation: Multiple backups, tested rollback plan
🟠 Medium Risk: Extended downtime
Cause: Large data volume or network issues
Mitigation: Test migration in advance, buffer time
🟡 Low Risk: Configuration gaps
Cause: Environment differences
Mitigation: Complete configuration checklistDependency Analysis
GDT maps out what depends on what:
You: Break down "release mobile app update"
GDT: 📋 Task Decomposition: Release Mobile App Update
1. Code complete [prerequisite]
- Merge all feature branches
- Resolve code conflicts
2. Testing [depends on: 1]
- Unit tests
- Integration tests
- UI automation tests
3. Beta testing [depends on: 2]
- Release beta version
- Collect tester feedback
- Fix discovered issues
4. Release materials [parallel with 2,3]
- Update app description
- Prepare screenshots
- Write changelog
5. Submit for review [depends on: 3, 4]
- iOS App Store submission
- Android Play Store submission
6. Release [depends on: 5]
- Monitor review status
- Publish
- User notification
📊 Dependency Graph:
┌─────┐
│ 1 │
└──┬──┘
│
┌──▼──┐
│ 2 │
└──┬──┘
│
┌──▼──┐ ┌─────┐
│ 3 │◄───│ 4 │ (parallel)
└──┬──┘ └──┬──┘
│ │
└────┬─────┘
│
┌──▼──┐
│ 5 │
└──┬──┘
│
┌──▼──┐
│ 6 │
└─────┘Interactive Refinement
When your request is vague, GDT asks for details:
You: Break down "prepare presentation"
GDT: To break this down accurately, I need some information:
1. What's the topic?
2. How long will it be?
3. Who's the audience? (technical, management, general)
4. When is the deadline?
5. Do you need slides?
You: AI product design, 20 minutes, for product team, next Wednesday, yes
GDT: 📋 Task Decomposition: AI Product Design Presentation
1. Outline content (30 min)
- Identify core theme
- List 3-4 key points
- Prepare cases and data
2. Create slides (2 hours)
- Design cover and template
- Write content for each slide
- Add images and charts
3. Prepare talking points (1 hour)
- Write notes for each slide
- Plan transitions
- Anticipate Q&A
4. Rehearse (1 hour)
- Practice 2-3 times
- Time yourself
- Adjust content
5. Final check (15 min)
- Test device compatibility
- Prepare backup files
⏱️ Estimated total: 4 hours 45 minutesAdjusting Estimates
GDT's estimates are starting points. Adjust them based on your situation:
You: Time estimates are too optimistic, I'm a beginner, add 50%
GDT: Adjusted time estimates (+50%):
1. Requirements and design: 2h → 3h
2. Set up project: 1h → 1.5h
3. Implement articles: 4h → 6h
4. Implement users: 3h → 4.5h
5. Implement comments: 2h → 3h
6. Deploy: 1h → 1.5h
⏱️ Adjusted total: 13h → 19.5h
Suggest spreading across 3-4 working days.Drilling Down
Ask for more detail on any step:
You: Break down step 3 "implement articles" further
GDT: 📋 Detailed Breakdown: Implement Article Module
3.1 Design data model (30 min)
- Define article table structure
- Design tag/category relationships
3.2 Implement API (1.5 hours)
- Create article endpoint
- List articles endpoint
- Get article detail endpoint
- Update/delete endpoints
3.3 Markdown rendering (1 hour)
- Select Markdown library
- Implement render component
- Handle code highlighting
3.4 Frontend pages (1 hour)
- Article list page
- Article detail page
- Article editor
⏱️ Subtask total: 4 hoursSaving as Subtasks
Once you're happy with a breakdown, save it to TaskWarrior:
You: Add all these subtasks to TaskWarrior
GDT: Created subtasks:
✅ ID:30 Requirements and design (project:BlogSystem)
✅ ID:31 Set up project (project:BlogSystem, depends:30)
✅ ID:32 Implement articles (project:BlogSystem, depends:31)
✅ ID:33 Implement users (project:BlogSystem, depends:31)
✅ ID:34 Implement comments (project:BlogSystem, depends:32,33)
✅ ID:35 Deploy (project:BlogSystem, depends:34)
Parent task "Develop blog system" marked as decomposed.Next Steps
- GTD Workflow — Organize decomposed tasks
- Privacy Controls — How decomposition data is stored