← 20.420.6 →
1707 words No Slides

Video 20.5: Task Lists and Dependencies

Course: Claude Code - Parallel Agent Development Section: S20 - Agent Teams Video Length: 4 minutes Presenter: Daniel Treasure

Opening Hook

The task list is the heartbeat of team coordination. It's where the lead assigns work, teammates volunteer, dependencies are tracked, and progress is visible. Let's see how to master it.

Key Talking Points

What to say:

What the Shared Task List Is - A JSON-based task board visible to all team members - Located at ~/.claude/tasks/{team-name}/ - Contains folders: pending, in-progress, completed - Each task is a file with metadata: title, description, assigned_to, status, dependencies - All teammates see the same board in real-time - This is the "single source of truth" for team work

Task States - Pending: Not yet started, waiting for assignment or teammate to pick it up - In Progress: Someone is actively working on it - Completed: Done, verified, closed - Tasks move through states as work progresses - Lead can view all tasks; teammates see their own and shared board

Task Assignment Patterns

  1. Lead-Assigned: Lead pushes tasks to specific teammates
  2. Use when you have a clear plan
  3. Example: "Assign the API design task to the architect"
  4. Teammates see their assignments in the task board

  5. Provides clear direction

  6. Self-Claim: Teammates volunteer for unassigned tasks

  7. Use when teammates have autonomy
  8. Teammates browse the pending list and pick what interests them
  9. Good for motivated teams or when there's flexibility

  10. Can lead to unexpected load balancing

  11. Hybrid: Some assigned, some self-claimed

  12. Most common in practice
  13. Lead assigns critical path work; teammates self-claim supporting tasks
  14. Balances direction with autonomy

Dependencies Between Tasks - Task A can block Task B: "Can't start frontend until API design is done" - Expressed in task metadata: "depends_on": ["api-design"] - Teammates respect dependencies: they can't mark a task done if it has blockers - Claude Code can warn teammates if they try to start blocked work - Dependencies ensure sequential work happens in the right order - Useful for: API before implementation, schema before ORM, tests before merge

Viewing and Managing the Task List - Press Ctrl+T to toggle task list view in Claude Code - See all tasks, their status, and who's working on what - Can drag tasks between states (UI or JSON) - Lead has full edit access; teammates work within their scope - Updates appear in real-time across all team members

Task Metadata (What's Tracked) - Title: What is this task? - Description: Detailed requirements or context - Assigned_to: Which teammate (or "unassigned") - Status: pending, in_progress, completed - Priority: High, medium, low (optional, helps guide effort) - Dependencies: List of task IDs this task depends on - Created_at / Updated_at: Metadata for tracking timeline - Completion_notes: How was it done? Any gotchas? (filled by completing teammate)

Lead's Task Management Responsibilities - Create clear, actionable tasks with good descriptions - Assign critical path work strategically - Unblock dependencies as upstream tasks complete - Review and approve completed work before marking done - Adjust priorities if blockers emerge - Communicate priority changes to affected teammates

Practical Workflow Example - Lead creates initial task set: design, api, frontend, tests, deploy - Lead assigns design to architect (highest seniority) - Design task moves to in-progress - Other tasks remain pending, waiting for design to complete - Architect finishes, marks design complete - Lead reviews, unblocks dependent tasks - API and frontend teammates now see their blocked tasks are ready - They pick them up and start working in parallel - Testing teammate can start once they have clear acceptance criteria

What to show on screen:

  • Terminal with task list view open (Ctrl+T)
  • Show the directory structure: ~/.claude/tasks/{team-name}/pending, in-progress, completed
  • Show a task JSON file with all metadata
  • Toggle task list view on and off
  • Show tasks in different states
  • Demonstrate assigning a task to a teammate
  • Show a teammate self-claiming a task
  • Show dependency blocking in action
  • Show the team board updating in real-time as work progresses

Demo Plan

0:00-0:45 - Show the Task List Structure - Open file manager and navigate to ~/.claude/tasks/{team-name}/ - Show the folder structure: pending, in-progress, completed - Open one task file (JSON) and show the metadata - Narrate: "Each task is a file with metadata. This is the team's shared to-do list" - Explain fields: title, assigned_to, status, dependencies, etc. - Show a few examples of different tasks

0:45-1:30 - Toggle the Task List View - In Claude Code, press Ctrl+T - Show the integrated task list view appear (cleaner than file browsing) - Narrate: "This is the lead's view of what everyone is working on" - Show pending, in-progress, and completed sections - Point out task titles, assignments, and status - Show how it's color-coded or visually organized

1:30-2:30 - Demonstrate Assignment and Dependencies - Create a simple multi-task scenario: Design → API → Frontend - Assign "API Design" task to the architect teammate - Watch it move to in-progress - Show that the "API Implementation" task is blocked (shows dependency) - Narrate: "The frontend teammate can see their task, but it's blocked. They can't start until the API is designed" - Show the blocking relationship in the task metadata - Assign the architect to do the design; watch progress

2:30-3:15 - Show Teammate Self-Claiming - Leave a task unassigned: "Write unit tests" - Show a teammate browsing the pending list and picking it up - Narrate: "The test teammate saw an unassigned task and decided to own it" - Show the task move from pending to in-progress with that teammate's name - Explain: "This autonomy is powerful—teammates feel agency"

3:15-3:45 - Show Completion and Unblocking - Simulate the architect finishing the API design task - Mark it complete - Narrate: "As soon as the design is done, the frontend task is no longer blocked" - Show dependent tasks automatically becoming available - Show the frontend teammate now able to start their work

3:45-4:00 - Lead-out - Emphasize that task list is the coordination hub - Next video is about direct communication between teammates - Tease: "Tasks assign work; messages let you discuss it in real time"

Code Examples & Commands

Task Toggling in Claude Code

# In Claude Code:
Ctrl+T          # Toggle task list view on/off

Example Task File Structure

{
  "id": "api-design",
  "title": "Design REST API endpoints",
  "description": "Define all endpoints, request/response schemas, error handling, authentication requirements. Focus on /users, /products, /orders resources.",
  "assigned_to": "api_architect",
  "status": "in_progress",
  "priority": "high",
  "depends_on": [],
  "created_at": "2025-02-13T10:00:00Z",
  "updated_at": "2025-02-13T10:15:00Z",
  "completion_notes": null
}

Task with Dependencies

{
  "id": "frontend-forms",
  "title": "Build form components for user signup",
  "description": "Create React components for signup form. Assume API endpoints are available at /api/users",
  "assigned_to": null,
  "status": "pending",
  "priority": "high",
  "depends_on": ["api-design", "api-implementation"],
  "created_at": "2025-02-13T10:00:00Z",
  "updated_at": "2025-02-13T10:00:00Z",
  "completion_notes": null
}

Completed Task Example

{
  "id": "api-design",
  "title": "Design REST API endpoints",
  "description": "Define all endpoints...",
  "assigned_to": "api_architect",
  "status": "completed",
  "priority": "high",
  "depends_on": [],
  "created_at": "2025-02-13T10:00:00Z",
  "updated_at": "2025-02-13T11:00:00Z",
  "completion_notes": "API designed with OpenAPI spec. All endpoints include validation. Ready for implementation."
}

Managing Tasks in Claude Code

# Lead assigning tasks to teammates:
> Assign the "API design" task to the architect

> Mark the "Database schema" task as in progress

> The "API implementation" task is ready to go—unblock it

> @frontend_dev, this task needs your attention

Lead Creates Initial Task Set

> Create these tasks for the team:
> - API design (depends on nothing, high priority)
> - Frontend component architecture (depends on API design)
> - Database schema (depends on API design)
> - Unit tests (depends on API implementation)
> - End-to-end tests (depends on everything)

Gotchas & Tips

Gotchas: - Changing a task directly (editing the JSON) doesn't always update the UI immediately; Ctrl+T refresh may be needed - Circular dependencies will block everyone: if Task A depends on B and B depends on A, nothing moves - Assigning a task to a teammate doesn't automatically notify them (they discover it by viewing the board) - If a dependency is deleted but a task still references it, the dependent task won't unblock - Pressing Ctrl+T in some terminal emulators might conflict with other bindings

Tips: - Start with small, clear tasks (4-8 per team initially); too many tasks create cognitive overload - Always describe the "why" in the task description, not just the "what" - Use dependencies strategically; every dependency is a synchronization point - Review completed tasks regularly; let teammates see the progress - Have the lead maintain the task list as a habit: it's your mirror of reality - Consider time estimates in task titles if your team moves fast: "API Design (2 hours)" - Color-code or tag tasks by category: "API", "Frontend", "Infrastructure", "Testing"

Lead-out

The task list keeps everyone synchronized on what needs doing. But how do teammates actually work together? In the next video, we'll explore real-time communication—sending messages directly to teammates, relaying information between specialist, and keeping conversations focused and productive.

Reference URLs

  • Claude Code Task Management: https://www.anthropic.com/claude-code/docs/agent-teams/tasks
  • Distributed Task Scheduling: https://www.anthropic.com/research/task-coordination
  • Project Management Best Practices: https://www.anthropic.com/claude-code/guides/team-workflows

Prep Reading

  • Review the concept of dependency graphs and critical path in project management
  • Understand how task blocking works in distributed systems
  • Think about how to write clear, actionable task descriptions
  • Consider what metadata matters most for your team's workflow

Notes for Daniel

The task list is not visually flashy, but it's conceptually important. Make the JSON readable and don't get lost in metadata details—focus on the key fields (title, status, assigned_to, depends_on). The dependency blocking is the "aha!" moment; make sure to show it clearly. When showing the Ctrl+T toggle, make the view change obvious so viewers can see the integrated interface. The workflow scenario (Design → API → Frontend) should be easy to follow; avoid complex dependency graphs for the demo. End on the note that tasks are the structure; messages are the conversation.