Skip to main content
skill CX Codex

task-dependency-patterns — Claude Code skill: tasks and setup

task-dependency-patterns is a Claude Code skill for splitting complex work into linked tasks. It covers status tracking and coordination across parallel work.

MIT 214 installs ★ 305 updated 2026-10-24

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add yonatangross/orchestkit --skill task-dependency-patterns -a claude-code
Open on GitHub

What task-dependency-patterns does

The skill explains how to create tasks with TaskCreate, update them with TaskUpdate, and inspect them through TaskGet and TaskList. Tasks can carry blocking dependencies and move through pending, in_progress, completed, or deleted states. The examples show how to break an implementation into smaller units.

A separate section covers Agent Teams, including shared task lists and teammate messaging. Claude Code 2.1.277 or later is required, and task tools are available only for certain models. For models outside that allowlist, an operator can enable them with CLAUDE_CODE_ENABLE_TODO_TOOLS=1 in user or managed settings, or in the shell.

What it helps with

  • split a multi-step implementation into trackable tasks
  • set execution order with blocking dependencies
  • check task status and find unfinished work
  • coordinate parallel work across agents

Example prompts for the agent

  • Break the authentication work into tasks and link their dependencies.
  • List unfinished tasks and assign an available one to an agent.
  • Plan parallel team work around a shared task list.

How to install task-dependency-patterns

1Skills CLI (Vercel)

npx skills add yonatangross/orchestkit --skill task-dependency-patterns -a claude-code

2Manually: put the files in place

~/.claude/skills/task-dependency-patterns/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/task-dependency-patterns/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about task-dependency-patterns

How do I install task-dependency-patterns in Claude Code?

Run npx skills add yonatangross/orchestkit --skill task-dependency-patterns -a claude-code. The skill file is located at ~/.claude/skills/task-dependency-patterns/SKILL.md.

What does task-dependency-patterns do?

It describes how to create tasks, change their status, and link dependencies with Claude Code task tools. It also covers coordination patterns for multiple agents.

What does task-dependency-patterns need to work?

It requires Claude Code 2.1.277 or later. For models outside the supported allowlist, task tools can be enabled with CLAUDE_CODE_ENABLE_TODO_TOOLS=1 in user or managed settings, or in the shell.

Source text

SKILL.md · MIT
---
name: task-dependency-patterns
license: MIT
compatibility: "Claude Code 2.1.277+."
description: Task Management patterns with TaskCreate, TaskUpdate, TaskGet, TaskList tools. Decompose complex work into trackable tasks with dependency chains. Use when managing multi-step implementations, coordinating parallel work, or tracking completion status.
user-invocable: false
disable-model-invocation: true
metadata:
  owner-agent: "workflow-architect"
  category: workflow-automation
  version: "1.0.0"
  author: "OrchestKit"
  complexity: "medium"
  tags: "task-management, dependencies, orchestration, workflow, coordination"
allowed-tools: "Read Glob Grep WebFetch WebSearch"
# Reference skill: fenced calls below teach a pattern, they are not calls this
# skill makes. Widening allowed-tools to satisfy the coverage gate would grant real
# permissions (Agent, CronCreate) to something that never acts.
tool-coverage: illustrative
---

# Task Dependency Patterns

## Overview

Claude Code 2.1.16 introduces a native Task Management System with four tools:
> **CC 2.1.268 caveat:** TaskCreate, TaskGet, TaskUpdate, TaskList, and TodoWrite are offered only on Claude 3.x, Opus 4.0 to 4.7, Sonnet 4.0 to 4.6, and Haiku 4.5. On models outside this allowlist, these tools are absent unless the operator sets `CLAUDE_CODE_ENABLE_TODO_TOOLS=1`. CC honours the flag only from user or managed settings (or the shell). ork cannot ship it (CC reads only `permissions` from plugin settings), so treat every Task-tool call in this skill as conditional on the operator's environment.

- **TaskCreate**: Create new tasks with subject, description, and activeForm
- **TaskUpdate**: Update status (pending → in_progress → completed), set dependencies
- **TaskGet**: Retrieve full task details including blockers
- **TaskList**: View all tasks with status and dependency summary

Tasks enable structured work tracking, parallel coordination, and clear progress visibility.

## When to Use

- Breaking down complex multi-step implementations
- Coordinating parallel work across multiple files
- Tracking progress on large features
- Managing dependencies between related changes
- Providing visibility into work status

## Key Patterns

### 1. Task Decomposition

Break complex work into atomic, trackable units:

```
Feature: Add user authentication

Tasks:
#1. [pending] Create User model
#2. [pending] Add auth endpoints (blockedBy: #1)
#3. [pending] Implement JWT tokens (blockedBy: #2)
#4. [pending] Add auth middleware (blockedBy: #3)
#5. [pending] Write integration tests (blockedBy: #4)
```

### 2. Dependency Chains

Use `addBlockedBy` to create execution order:

```json
// Task #3 cannot start until #1 and #2 complete
{"taskId": "3", "addBlockedBy": ["1", "2"]}
```

### 3. Status Workflow

```
pending → in_progress → completed
   ↓           ↓
(unblocked)  (active)

pending/in_progress → deleted
```

- **pending**: Task created but not started
- **in_progress**: Actively being worked on
- **completed**: Work finished and verified
- **deleted**: Task removed — permanently removes the task

### Task Deletion

Use `status: "deleted"` to permanently remove tasks:

```json
// Delete a task
{"taskId": "3", "status": "deleted"}
```

**When to delete:**
- Orphaned tasks whose blockers have all failed
- Tasks superseded by a different approach
- Duplicate tasks created in error
- Tasks from a cancelled pipeline

**When NOT to delete:**
- Tasks that might be retried later (keep as pending)
- Tasks with useful history (mark completed instead)
- Tasks blocked by in_progress work (wait for resolution)

### 4. activeForm Pattern

Provide present-continuous form for spinner display:

| subject (imperative) | activeForm (continuous) |
|---------------------|------------------------|
| Run tests | Running tests |
| Update schema | Updating schema |
| Fix authentication | Fixing authentication |

## Agent Teams

Agent Teams provides multi-agent coordination with shared task lists and peer-to-peer messaging.

> **CC 2.1.161 — independent parallel-tool failure:** A failed tool call in a parallel batch no longer cancels siblings; each returns its own result. Teammates must check task status independently and handle failures explicitly rather than assuming a batch-wide abort.

### Team Workflow

```
1. (implicit team — CC 2.1.178+)       → one team per session; no TeamCreate
2. TaskCreate(subject, description)    → Add tasks to shared list
3. Agent(name, team_name, prompt)      → Spawn teammates into the implicit team
4. TaskUpdate(owner: "teammate-name")  → Assign tasks
5. SendMessage(to, message, summary)   → Direct teammate communication
6. (turn / background ends)            → teammates wind down; Ctrl+F x2 for bg
```

> **Cross-session replies land in the parent (CC 2.1.248):** when a subagent sends `SendMessage` to another session, the reply is delivered to the parent session's conversation, never to the subagent; a subagent sends and moves on, the parent reads the answer. Cross-session `SendMessage` / `ListAgents` also work on Bedrock, Vertex and Foundry and with telemetry disabled (CC 2.1.248).

### When to Use Teams vs Agent Tool

| Criteria | Agent Tool (subagents) | Agent Teams |
|----------|----------------------|-------------|
| Independent tasks | Yes | Overkill |
| Cross-cutting changes | Limited | Yes |
| Agents need to talk | No (star topology) | Yes (mesh) |
| Cost sensitivity | Lower (~1x) | Higher (~2.5x) |
| Complexity < 3.0 | Yes | No |
| Complexity > 3.5 | Possible | Recommended |

### Team Task Patterns

```
# Spawn teammate into shared task list. A teammate that writes files works in
# a manual worktree the lead creates first (#4557); the lead merges its branch
# before dependent tasks start. No isolation on the call: a call with name and
# isolation launches a plain subagent, not a teammate (Claude Code docs).
Bash("git worktree add .worktrees/backend -b feat/my-feature-backend feat/my-feature")
Agent(
  prompt="You are the backend architect... Work only in .worktrees/backend/ "
         "(cd there, check pwd and branch first). Commit your work there and "
         "message the lead your branch name and commit sha.",
  team_name="my-feature",
  name="backend-architect",
  subagent_type="ork:backend-system-architect"
)

# Teammate claims and works tasks
TaskList → find unblocked, unowned tasks
TaskUpdate(taskId, owner: "backend-architect", status: "in_progress")
# ... do work ...
TaskUpdate(taskId, status: "completed")
TaskList → find next task
```

### Peer Messaging

```
# Direct message between teammates (params: to, message, summary)
SendMessage(to: "frontend-dev",
  message: "API contract ready: GET /users/:id returns {...}",
  summary: "API contract shared")

# No broadcast primitive — send to each teammate, or post to the shared
# task list (TaskCreate/TaskUpdate) so every teammate sees it
SendMessage(to: "backend-dev",
  message: "Breaking change: auth header format changed",
  summary: "Breaking auth change")
```

## Context Exhaustion Handling

When using Agent Teams, if context limit is reached mid-workflow:
- Collect partial results from completed teammates via `TaskList`
- Synthesize available outputs — prefer partial results over silent failure
- Log skipped tasks with `TaskUpdate(taskId: task_id, status: "completed", metadata: {"skipped": "context limit"})`

## Anti-Patterns

- Creating tasks for trivial single-step work
- Circular dependencies (A blocks B, B blocks A)
- Leaving tasks in_progress when blocked
- Not marking tasks completed after finishing
- Using broadcast for messages that only concern one teammate
- Spawning teams for simple sequential work (use Agent tool instead)

## Related Skills

- `ork:implement` - Implementation workflow with task tracking and progress updates
- `ork:verify` - Verification tasks and completion checklists
- `ork:fix-issue` - Issue resolution with hypothesis-based RCA tracking
- `ork:brainstorm` - Design exploration with parallel agent tasks

## References

Load on demand with `Read("references/<file>")`:

| File | Content |
|------|---------|
| `dependency-tracking.md` | Dependency tracking patterns |
| `status-workflow.md` | Status workflow details |
| `multi-agent-coordination.md` | Multi-agent coordination |

© OrchestKit · MIT · yonatangross/orchestkit

Similar skills

All skills for Agent setup: memory, context, orchestration →

From the same set86

The whole set →
fix-issue The fix-issue skill investigates a GitHub issue, applies a tested fix, opens a linked PR, and records ways to prevent the bug from returning. CX Codex +1 217installs review-pr review-pr is a Claude Code skill that reviews a pull request, branch, or diff range with parallel agents. It returns an approve or request-changes verdict before a merge. CX Codex +1 217installs i18n-date-patterns i18n-date-patterns guides an agent through React translations and locale-aware formatting. Use it when adding languages, handling dates or currency, or writing pluralized messages. CX Codex +1 216installs design-system-tokens design-system-tokens builds W3C token files for colors, spacing, and themes. It applies while creating .tokens.json files or setting up dark mode. CX Codex +1 215installs api-design api-design establishes design standards for REST, GraphQL, and gRPC contracts when editing endpoints or OpenAPI files. Triggers on route definitions and schema changes. CX Codex +1 211installs assess The assess skill rates code or design decisions 0-10 across seven dimensions: correctness, readability, complexity, performance, security, maintainability and compliance. CX Codex +1 211installs verify verify is a skill that checks whether work is ready to merge by running tests, security and type checks, then assigns a 0–10 score. CX Codex +1 210installs commit Creates Conventional Commits with scope detection, Co-Authored-By trailers and pre-commit checks; blocks secrets and generated files. Runs on commit or “save my changes”. CX Codex +1 210installs

Project sponsors

Companies that keep this analytics open