Project 32: TODO List Automator
Project 32: TODO List Automator
Build a workflow using Kiro CLI’s TODO list and Thinking Tool features to decompose complex tasks, track progress, and visualize AI reasoning in real-time.
Quick Reference
| Attribute | Value |
|---|---|
| Difficulty | Intermediate (Level 2) |
| Time Estimate | Weekend |
| Primary Language | Natural Language / Markdown |
| Alternative Languages | N/A |
| Prerequisites | Projects 1-5, basic Kiro CLI familiarity |
| Key Topics | Task decomposition, AI reasoning visualization, progress tracking, task dependencies |
| Kiro CLI Concepts | /todo command, Thinking Tool, experimental features, task state management |
| Main Book Reference | “Getting Things Done” by David Allen |
1. Learning Objectives
By completing this project, you will:
- Master Kiro CLI’s TODO feature: Understand how to use
/todofor structured task management during development sessions - Visualize AI reasoning with the Thinking Tool: Learn how Claude’s extended thinking works and how to leverage visible reasoning
- Implement intelligent task decomposition: Use AI to break complex goals into actionable, ordered subtasks
- Design task dependency management: Create workflows where tasks unlock based on completion of prerequisites
- Build productive development patterns: Establish personal workflows that maximize AI-assisted productivity
2. Deep Theoretical Foundation
2.1 The Cognitive Science of Task Management
From “Getting Things Done” (David Allen, Ch. 2): The human brain is excellent at having ideas but terrible at holding them. Writing tasks down frees mental capacity for execution.
THE GTD WORKFLOW MODEL
┌─────────────────────────────────────────────────────────────────────────┐
│ │
│ CAPTURE │
│ ─────── │
│ "Build a user authentication system with OAuth" │
│ │ │
│ ▼ │
│ CLARIFY │
│ ─────── │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ Is this a single action or a project? │ │
│ │ → Project (multiple steps required) │ │
│ │ │ │
│ │ What's the desired outcome? │ │
│ │ → Users can log in via Google/GitHub OAuth │ │
│ │ │ │
│ │ What's the next action? │ │
│ │ → Set up OAuth provider configuration │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ORGANIZE │
│ ──────── │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ [ ] Set up OAuth provider configuration │ │
│ │ [ ] Create user database schema │ │
│ │ [ ] Implement OAuth callback handler │ │
│ │ [ ] Add session management │ │
│ │ [ ] Create login/logout UI components │ │
│ │ [ ] Add route protection middleware │ │
│ │ [ ] Write integration tests │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ENGAGE │
│ ────── │
│ [✓] Set up OAuth provider configuration ← Working on this now │
│ [ ] Create user database schema │
│ ... │
│ │
└─────────────────────────────────────────────────────────────────────────┘
Key Insight: Kiro CLI’s TODO feature automates the Clarify and Organize phases - AI breaks down your goal and creates the task list, freeing you to focus on execution.
2.2 The Thinking Tool: Visible AI Reasoning
The Thinking Tool (extended thinking) allows Claude to reason through problems before responding. This makes AI decision-making transparent and debuggable.
THINKING TOOL VISUALIZATION
┌─────────────────────────────────────────────────────────────────────────┐
│ │
│ USER REQUEST │
│ ───────────── │
│ "Build a user authentication system with OAuth" │
│ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ THINKING TOOL │ │
│ │ ───────────── │ │
│ │ │ │
│ │ ├── Understanding scope │ │
│ │ │ • OAuth implies third-party authentication │ │
│ │ │ • Need to handle tokens, sessions, callbacks │ │
│ │ │ • Multiple providers (Google, GitHub, etc.) │ │
│ │ │ │ │
│ │ ├── Identifying components │ │
│ │ │ • Provider configuration (credentials) │ │
│ │ │ • Database schema for users │ │
│ │ │ • Callback handlers for OAuth flow │ │
│ │ │ • Session management │ │
│ │ │ • UI components │ │
│ │ │ • Route protection │ │
│ │ │ │ │
│ │ ├── Ordering by dependencies │ │
│ │ │ • Config first (everything depends on it) │ │
│ │ │ • Database second (handlers need it) │ │
│ │ │ • Handlers third (UI needs them) │ │
│ │ │ • UI last (depends on everything) │ │
│ │ │ │ │
│ │ └── Estimating effort │ │
│ │ • Config: 15 min │ │
│ │ • Database: 20 min │ │
│ │ • Handlers: 45 min │ │
│ │ • ... │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ GENERATED TODO LIST │
│ ─────────────────── │
│ [ ] 1. Set up OAuth provider configuration (15 min) │
│ [ ] 2. Create user database schema (20 min) │
│ ... │
│ │
└─────────────────────────────────────────────────────────────────────────┘
2.3 Task State Machine
Tasks flow through defined states. Understanding this enables better workflow design:
TASK STATE MACHINE
┌─────────────────────────────────────────────────────────────────────────┐
│ │
│ ┌─────────────┐ │
│ │ PENDING │ │
│ │ [ ] │ │
│ └──────┬──────┘ │
│ │ │
│ │ "Start task 1" │
│ │ │
│ ▼ │
│ ┌─────────────┐ │
│ ┌────────│ IN_PROGRESS │────────┐ │
│ │ │ [~] │ │ │
│ │ └──────┬──────┘ │ │
│ │ │ │ │
│ Blocked │ │ Complete │ Blocked by │
│ by failure│ │ │ dependency │
│ │ ▼ │ │
│ │ ┌─────────────┐ │ │
│ │ │ COMPLETED │ │ │
│ │ │ [✓] │ │ │
│ │ └─────────────┘ │ │
│ │ │ │
│ ▼ ▼ │
│ ┌─────────────┐ ┌─────────────┐ │
│ │ FAILED │ │ BLOCKED │ │
│ │ [✗] │ │ [⏸] │ │
│ └──────┬──────┘ └──────┬──────┘ │
│ │ │ │
│ │ Retry │ Dependency complete │
│ │ │ │
│ └───────────────┬───────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────┐ │
│ │ PENDING │ │
│ │ [ ] │ │
│ └─────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
State indicators:
[ ] Pending - Ready to start
[~] In Progress - Currently being worked on
[✓] Completed - Successfully finished
[✗] Failed - Encountered error, needs attention
[⏸] Blocked - Waiting for dependency
2.4 Task Decomposition Strategies
Different types of goals require different decomposition approaches:
DECOMPOSITION STRATEGIES
┌─────────────────────────────────────────────────────────────────────────┐
│ │
│ STRATEGY 1: COMPONENT-BASED │
│ ──────────────────────────── │
│ Best for: Feature development, new functionality │
│ │
│ "Add user profiles" │
│ │ │
│ ├── Database: Create profiles table │
│ ├── API: Implement CRUD endpoints │
│ ├── Frontend: Build profile components │
│ └── Tests: Write integration tests │
│ │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ STRATEGY 2: WORKFLOW-BASED │
│ ───────────────────────── │
│ Best for: Process automation, CI/CD │
│ │
│ "Set up deployment pipeline" │
│ │ │
│ ├── Step 1: Configure build script │
│ ├── Step 2: Set up test automation │
│ ├── Step 3: Create staging environment │
│ ├── Step 4: Implement deployment script │
│ └── Step 5: Add monitoring and alerts │
│ │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ STRATEGY 3: ITERATIVE │
│ ──────────────────── │
│ Best for: Improvements, refactoring │
│ │
│ "Improve API performance" │
│ │ │
│ ├── Iteration 1: Add caching layer │
│ ├── Iteration 2: Optimize database queries │
│ ├── Iteration 3: Implement pagination │
│ └── Iteration 4: Add response compression │
│ │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ STRATEGY 4: DEPENDENCY-ORDERED │
│ ────────────────────────────── │
│ Best for: Complex features with prerequisites │
│ │
│ "Implement payment processing" │
│ │ │
│ ├── [No deps] Set up Stripe account │
│ ├── [Deps: 1] Add Stripe SDK │
│ ├── [Deps: 2] Create payment service │
│ ├── [Deps: 3] Build checkout UI │
│ ├── [Deps: 3] Implement webhooks │
│ └── [Deps: 4,5] Add order confirmation │
│ │
└─────────────────────────────────────────────────────────────────────────┘
2.5 The TODO Tool API
Understanding the TODO tool’s interface helps you use it effectively:
TODO TOOL INTERFACE
┌─────────────────────────────────────────────────────────────────────────┐
│ │
│ COMMANDS │
│ ──────── │
│ │
│ /todo View current task list │
│ /todo "description" Add new task │
│ /todo start <n> Begin working on task n │
│ /todo done <n> Mark task n complete │
│ /todo remove <n> Remove task n │
│ /todo clear Clear all tasks │
│ /todo reorder Reorganize task order │
│ │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ NATURAL LANGUAGE INTERFACE │
│ ────────────────────────── │
│ │
│ Instead of commands, you can say: │
│ │
│ "Break this down into tasks" │
│ → AI decomposes goal into ordered task list │
│ │
│ "What should I work on next?" │
│ → AI suggests highest-priority pending task │
│ │
│ "I finished the OAuth setup" │
│ → AI marks relevant task complete │
│ │
│ "This task is blocked by X" │
│ → AI updates task status and dependencies │
│ │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ ENABLING THE TODO FEATURE │
│ ────────────────────────── │
│ │
│ In your settings.json or via CLI: │
│ │
│ kiro-cli settings chat.enableTodo true │
│ │
│ Or in agent configuration: │
│ │
│ { │
│ "experimental": { │
│ "enableTodo": true, │
│ "enableThinking": true │
│ } │
│ } │
│ │
└─────────────────────────────────────────────────────────────────────────┘
3. Complete Project Specification
3.1 What You Will Build
A personal productivity workflow using Kiro CLI that:
- Takes high-level development goals as input
- Uses the Thinking Tool to analyze and decompose tasks
- Creates structured TODO lists with dependencies
- Tracks progress through task states
- Provides intelligent suggestions for next actions
- Generates progress reports and summaries
3.2 Functional Requirements
| Requirement | Description |
|---|---|
| Goal Input | Accept complex development goals in natural language |
| Task Decomposition | Break goals into atomic, actionable tasks |
| Dependency Detection | Identify which tasks depend on others |
| Progress Tracking | Track task states (pending, in-progress, done) |
| Smart Suggestions | Recommend next task based on dependencies |
| Time Estimation | Estimate effort for each task |
| Progress Reports | Summarize work completed and remaining |
3.3 Non-Functional Requirements
- Persistence: Task lists survive session restarts
- Clarity: Task descriptions are actionable and unambiguous
- Efficiency: Decomposition happens in seconds
- Flexibility: Tasks can be added, removed, or reordered
4. Solution Architecture
4.1 Workflow Architecture
┌──────────────────────────────────────────────────────────────────────────────┐
│ TODO AUTOMATOR WORKFLOW │
├──────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────────────────────┐ │
│ │ INPUT LAYER │ │
│ │ │ │
│ │ "Build a REST API for a blog with posts, comments, and users" │ │
│ │ │ │
│ └────────────────────────────────────┬────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────────────────────┐ │
│ │ THINKING TOOL │ │
│ │ │ │
│ │ ├── Analyzing requirements... │ │
│ │ │ • REST API implies HTTP endpoints │ │
│ │ │ • Blog domain: posts, comments, users │ │
│ │ │ • Need CRUD for each entity │ │
│ │ │ │ │
│ │ ├── Identifying components... │ │
│ │ │ • Database models │ │
│ │ │ • Route handlers │ │
│ │ │ • Validation │ │
│ │ │ • Authentication │ │
│ │ │ │ │
│ │ └── Determining order... │ │
│ │ • Models first → Routes → Auth → Tests │ │
│ │ │ │
│ └────────────────────────────────────┬────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────────────────────┐ │
│ │ TODO LIST MANAGER │ │
│ │ │ │
│ │ ┌───────────────────────────────────────────────────────────────────┐ │ │
│ │ │ # │ Task │ Status │ Deps │ │ │
│ │ ├───┼───────────────────────────────────────────┼────────┼─────────┤ │ │
│ │ │ 1 │ Set up project structure │ [ ] │ None │ │ │
│ │ │ 2 │ Create User model │ [ ] │ 1 │ │ │
│ │ │ 3 │ Create Post model │ [ ] │ 1 │ │ │
│ │ │ 4 │ Create Comment model │ [ ] │ 2,3 │ │ │
│ │ │ 5 │ Implement User CRUD routes │ [ ] │ 2 │ │ │
│ │ │ 6 │ Implement Post CRUD routes │ [ ] │ 3 │ │ │
│ │ │ 7 │ Implement Comment routes │ [ ] │ 4 │ │ │
│ │ │ 8 │ Add authentication middleware │ [ ] │ 5 │ │ │
│ │ │ 9 │ Write integration tests │ [ ] │ 5,6,7 │ │ │
│ │ └───┴───────────────────────────────────────────┴────────┴─────────┘ │ │
│ │ │ │
│ └────────────────────────────────────┬────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────────────────────┐ │
│ │ EXECUTION LOOP │ │
│ │ │ │
│ │ User: "Start task 1" │ │
│ │ ┌─────────────────────────────────────────────────────────────────┐ │ │
│ │ │ [Kiro] Working on: Set up project structure │ │ │
│ │ │ │ │ │
│ │ │ [Thinking Tool] Planning implementation... │ │ │
│ │ │ ├── Initialize npm project │ │ │
│ │ │ ├── Install dependencies (express, prisma, etc.) │ │ │
│ │ │ ├── Create folder structure │ │ │
│ │ │ └── Set up TypeScript config │ │ │
│ │ │ │ │ │
│ │ │ Creating files... │ │ │
│ │ │ ✓ package.json │ │ │
│ │ │ ✓ tsconfig.json │ │ │
│ │ │ ✓ src/index.ts │ │ │
│ │ │ ✓ src/routes/ │ │ │
│ │ │ ✓ src/models/ │ │ │
│ │ └─────────────────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ │ [TODO] Task 1 complete. Next available: Tasks 2, 3 (no blockers) │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────────────┘ │
│ │
└──────────────────────────────────────────────────────────────────────────────┘
4.2 Data Structures
// Core types for TODO automator
interface Task {
id: number;
description: string;
status: TaskStatus;
dependencies: number[]; // IDs of tasks this depends on
estimatedMinutes: number;
createdAt: Date;
startedAt?: Date;
completedAt?: Date;
notes: string[];
}
type TaskStatus = 'pending' | 'in_progress' | 'completed' | 'blocked' | 'failed';
interface TodoList {
goal: string;
tasks: Task[];
createdAt: Date;
lastUpdated: Date;
}
interface ProgressReport {
totalTasks: number;
completedTasks: number;
inProgressTasks: number;
blockedTasks: number;
estimatedTimeRemaining: number;
percentComplete: number;
}
interface ThinkingOutput {
steps: ThinkingStep[];
conclusion: string;
decomposition: TaskDecomposition;
}
interface ThinkingStep {
phase: 'analyzing' | 'identifying' | 'ordering' | 'estimating';
content: string[];
}
interface TaskDecomposition {
tasks: Omit<Task, 'id' | 'status' | 'createdAt'>[];
dependencyGraph: Map<number, number[]>;
criticalPath: number[];
}
5. Phased Implementation Guide
Phase 1: Basic TODO Setup (Day 1 Morning)
Goals:
- Enable TODO feature in Kiro CLI
- Create first TODO list manually
- Understand task state management
Tasks:
- Enable TODO feature in settings
- Create a simple TODO list with
/todo - Practice adding, starting, completing tasks
- Observe how tasks persist across messages
Milestone Checkpoint:
$ kiro-cli chat
> /todo
[TODO] No active tasks. Describe what you'd like to accomplish.
> /todo "Learn the Kiro CLI TODO feature"
[TODO] Added: Learn the Kiro CLI TODO feature
> /todo start 1
[TODO] Started: Learn the Kiro CLI TODO feature
> /todo done 1
[TODO] Completed: Learn the Kiro CLI TODO feature
Hint 1: Use kiro-cli settings --list to see all available settings including experimental features.
Phase 2: AI-Driven Decomposition (Day 1 Afternoon)
Goals:
- Use AI to automatically decompose goals
- Observe Thinking Tool reasoning
- Understand how dependencies are detected
Tasks:
- Give AI a complex development goal
- Watch Thinking Tool break it down
- Review generated task list
- Modify tasks as needed
Milestone Checkpoint:
> "Build a simple REST API for a to-do app with Express"
[Thinking Tool] Breaking down task...
├── Analyzing requirements
├── Identifying components
├── Ordering by dependencies
└── Estimating effort
[TODO] Generated 7 tasks:
┌───┬────────────────────────────────────┬────────┬─────────┐
│ # │ Task │ Status │ Est. │
├───┼────────────────────────────────────┼────────┼─────────┤
│ 1 │ Initialize Express project │ [ ] │ 10 min │
│ 2 │ Create Todo model/schema │ [ ] │ 15 min │
│ 3 │ Implement GET /todos endpoint │ [ ] │ 15 min │
│ 4 │ Implement POST /todos endpoint │ [ ] │ 15 min │
│ 5 │ Implement PUT /todos/:id endpoint │ [ ] │ 15 min │
│ 6 │ Implement DELETE /todos/:id │ [ ] │ 10 min │
│ 7 │ Add error handling middleware │ [ ] │ 15 min │
└───┴────────────────────────────────────┴────────┴─────────┘
Total estimated time: 1h 35min
Hint 2: You can refine the decomposition by saying “Break this down into smaller tasks” or “This task seems too big, can you split it?”
Phase 3: Workflow Execution (Day 2 Morning)
Goals:
- Execute tasks with AI assistance
- Track progress through completion
- Handle blocked and failed states
Tasks:
- Start first task and observe AI implementation
- Mark tasks complete as you progress
- Observe how dependencies unlock next tasks
- Simulate a failure and observe recovery
Milestone Checkpoint:
> "Start task 1"
[Kiro] Working on: Initialize Express project
[Thinking Tool] Planning implementation...
├── Create package.json
├── Install express and dependencies
├── Create src/index.ts entry point
└── Add npm scripts
Creating files...
✓ package.json
✓ src/index.ts
✓ npm install complete
[TODO] Task 1 complete!
Progress: 1/7 tasks (14%)
Next available: Task 2 (Create Todo model/schema)
Phase 4: Progress Tracking (Day 2 Afternoon)
Goals:
- Generate progress reports
- Understand critical path analysis
- Create session summaries
Tasks:
- Complete several tasks
- Request progress report
- Analyze remaining work
- Generate session summary
Milestone Checkpoint:
> "Show my progress"
[TODO] Progress Report
━━━━━━━━━━━━━━━━━━━━━━
Goal: Build a simple REST API for a to-do app
Progress: ████████░░░░░░░░░░░░ 40% (3/7 tasks)
Completed:
✓ Initialize Express project (10 min)
✓ Create Todo model/schema (15 min)
✓ Implement GET /todos endpoint (15 min)
In Progress:
~ Implement POST /todos endpoint (15 min)
Remaining:
• Implement PUT /todos/:id endpoint (15 min)
• Implement DELETE /todos/:id (10 min)
• Add error handling middleware (15 min)
Time spent: 45 min
Time remaining: ~55 min
[Thinking Tool] Analysis:
Tasks 5-6 can be parallelized if you split the work.
Task 7 (error handling) is on the critical path.
Hint 3: Ask “What’s blocking me?” to see dependencies, or “What can I parallelize?” for efficiency tips.
6. Testing Strategy
6.1 Manual Testing Scenarios
Since this project is primarily about workflow patterns, testing is more experiential than automated.
Scenario 1: Simple Decomposition
Input: "Add a login page to my React app"
Expected: 3-5 tasks covering component creation, styling, routing
Verify: Tasks are ordered logically (component before integration)
Scenario 2: Complex Decomposition
Input: "Build a complete e-commerce checkout flow"
Expected: 10+ tasks with clear dependencies
Verify: Dependencies are correctly identified (payment after cart)
Scenario 3: Blocked Task Handling
Steps:
1. Create tasks with dependencies
2. Try to start a blocked task
3. Verify system prevents or warns
Expected: Clear message about what's blocking
Scenario 4: Progress Report Accuracy
Steps:
1. Complete 3 of 5 tasks
2. Request progress report
3. Verify percentages and remaining time
Expected: 60% complete, accurate time estimates
6.2 Quality Checks
| Aspect | Check | Pass Criteria |
|---|---|---|
| Decomposition Quality | Tasks are atomic | Each task can be done in one sitting |
| Dependency Accuracy | No circular deps | System warns or prevents |
| Time Estimates | Reasonable for scope | Within 2x of actual |
| Progress Tracking | Accurate counts | Matches actual completions |
| State Transitions | Correct flow | pending → in_progress → completed |
7. Common Pitfalls and Debugging
7.1 Common Issues
| Pitfall | Symptom | Solution |
|---|---|---|
| Vague tasks | “Implement feature” unclear | Ask for more specific decomposition |
| Missing dependencies | Task fails because prereq not done | Review and add dependencies |
| Over-decomposition | 50 tiny tasks | Ask to group related tasks |
| Under-decomposition | Tasks take hours | Ask to break down large tasks |
| Circular dependencies | Tasks block each other | Identify and break the cycle |
7.2 Debugging Strategies
1. View Thinking Tool reasoning:
> "Show me your reasoning for this decomposition"
[Thinking Tool] Reasoning trace:
├── The goal mentions "authentication"
├── Authentication requires user model
├── User model requires database setup
├── Therefore: Database → User Model → Auth
2. Check dependency graph:
> "Show me the dependency graph"
[TODO] Dependency Graph:
Task 1: Initialize project
└─► Task 2: Create models
└─► Task 3: Create routes
└─► Task 4: Add auth
└─► Task 5: Tests
3. Validate estimates:
> "These time estimates seem off. Can you re-estimate based on my skill level?"
[Thinking Tool] Adjusting estimates...
├── You mentioned being new to Express
├── Increasing estimates by 50%
├── Adding buffer for learning curve
8. Extensions and Challenges
8.1 Beginner Extensions
- Create a TODO list template for common tasks (bug fixes, features, refactoring)
- Add tags to tasks for categorization (frontend, backend, testing)
- Export TODO list to markdown file
8.2 Intermediate Extensions
- Create recurring task patterns for daily/weekly workflows
- Integrate with external task managers (Notion, Linear, Jira)
- Build a “standup report” generator from completed tasks
8.3 Advanced Extensions
- Implement parallel task execution with coordination
- Create team-based task distribution
- Build velocity tracking and estimate improvement
9. Real-World Connections
9.1 Industry Practices
| Practice | Connection to This Project |
|---|---|
| Agile Sprints | TODO decomposition mirrors backlog grooming |
| Kanban Boards | Task states map to board columns |
| GTD Methodology | Capture → Clarify → Organize → Engage |
| Project Planning | Dependency graphs = critical path method |
9.2 Professional Applications
- Sprint Planning: Use TODO decomposition for story breakdown
- Daily Standups: Generate “what I did / what I’ll do” from task history
- Time Estimation: Improve estimates by tracking actual vs. predicted
- Onboarding: Create TODO templates for new team members
10. Self-Assessment Checklist
Understanding Verification
- I can explain the GTD workflow phases
- I understand task state transitions
- I can describe how the Thinking Tool aids decomposition
- I know when to use different decomposition strategies
- I can identify task dependencies correctly
Implementation Verification
- I enabled the TODO feature in Kiro CLI
- I created and managed a TODO list
- I observed Thinking Tool reasoning
- I tracked progress through task states
- I generated a progress report
Integration Verification
- I used TODO for a real development task
- AI decomposition matched my needs
- I refined tasks based on actual work
- I completed a full goal using this workflow
11. Completion Criteria
Minimum Viable Completion
- Enable and use /todo command
- Create a task list from a goal
- Complete at least 3 tasks tracking states
- Generate basic progress report
Full Completion
- Use Thinking Tool for intelligent decomposition
- Handle task dependencies correctly
- Create custom decomposition templates
- Integrate TODO into daily workflow
Excellence (Going Above and Beyond)
- Build reusable task templates
- Create automated progress reports
- Integrate with external tools
- Train the system on your estimation patterns
This guide was expanded from LEARN_KIRO_CLI_MASTERY.md. For the complete learning path, see the README.