---
name: claude-devfleet
description: Plan and run coding work with many Claude Code agents through Claude DevFleet. Each agent works in its own Git worktree. Review the plan, track work, and read clear reports.
origin: community
---

# Claude DevFleet

> **Community skill. Full credit goes to the original author.**

## When to Use

Use this skill when a coding job has parts that agents can do at the same time.

Good tasks include:

- Building separate app parts
- Adding code and tests
- Fixing bugs in different files
- Reviewing a large change

Do not use it for a small task that one agent can finish fast.

Each agent works in its own Git worktree. DevFleet can merge finished work.

## Setup

A Claude DevFleet server must be running at port `18801`.

Add it to Claude Code:

```bash
claude mcp add devfleet --transport http http://localhost:18801/mcp
```

If the server cannot be reached, stop and tell the user. Do not start work outside DevFleet unless the user agrees.

## Main Flow

```text
User asks for a project
  |
  v
plan_project(prompt)
  |
  v
Show the plan and ask for approval
  |
  v
dispatch_mission(first_mission_id)
  |
  v
Watch each mission
  |
  v
Read each report
  |
  v
Check merge results and tell the user
```

## Tools

| Tool | What it does |
|---|---|
| `plan_project(prompt)` | Makes a project and a list of linked missions. Returns a `project_id`. |
| `create_project(name, path?, description?)` | Makes a project by hand. Returns a `project_id`. |
| `create_mission(project_id, title, prompt, depends_on?, auto_dispatch?)` | Adds a mission. `depends_on` is a list of mission ID strings. Set `auto_dispatch=true` to start it after all needed missions pass. |
| `dispatch_mission(mission_id, model?, max_turns?)` | Starts one mission. |
| `cancel_mission(mission_id)` | Stops a mission that is still running. |
| `wait_for_mission(mission_id, timeout_seconds?)` | Waits for a mission. A timeout does not mean the mission failed. |
| `get_mission_status(mission_id)` | Checks a mission without waiting. |
| `get_report(mission_id)` | Gets the final report, such as changed files, work done, errors, and next steps. |
| `get_dashboard()` | Shows active agents and system totals. |
| `list_projects()` | Lists all projects. |
| `list_missions(project_id, status?)` | Lists missions in one project. You may filter by status. |

## Steps

1. Call `plan_project` with the full task.
2. Check that each mission has one clear goal.
3. Check all links between missions.
4. Show the plan to the user.
5. Get approval before you start agents.
6. Start missions that have no unmet needs.
7. Use `get_mission_status` to check progress.
8. Use `get_report` after each mission ends.
9. Confirm that merges passed.
10. Tell the user what changed, what failed, and what is left.

## Safety Rules

- Do not start agents before the user approves the plan.
- Do not run two missions at once if they edit the same files.
- Put shared setup work in an early mission.
- Use `depends_on` when one mission needs code from another.
- Use `auto_dispatch=true` only when the next mission is safe to start on its own.
- Set a fair `max_turns` for work that could run too long.
- Do not cancel a mission just because `wait_for_mission` timed out. Check its status first.
- If a mission fails, read its report before trying again.
- Do not start missions that depend on a failed mission.
- If a merge fails, stop new linked work. Report the conflict.
- If an agent changes files outside its task, report those files.
- Never hide errors or claim that unfinished work is done.
- Do not add web calls, tracking, analytics, or telemetry.

## Example

The user asks:

```text
Build a REST API with login and tests.
```

First, make a plan:

```text
plan_project(
  prompt="Build a REST API with user login, token checks, input checks, and tests. Keep API code and test code in separate missions when safe."
)
```

Show the returned missions. Ask the user to approve them.

A good plan may look like this:

```text
M1: Add the API base and data model
M2: Add login and token checks
    depends_on: [M1]
M3: Add API tests
    depends_on: [M2]
```

After approval, start the first mission:

```text
dispatch_mission(
  mission_id="M1",
  max_turns=20
)
```

Check it without blocking:

```text
get_mission_status(mission_id="M1")
```

When it ends, read the report:

```text
get_report(mission_id="M1")
```

If M1 passed and merged, start M2. If later missions use `auto_dispatch=true`, confirm they started only after their needs passed.

At the end, report:

```text
Done:
- Added the API base.
- Added login and token checks.
- Added tests.

Checks:
- All missions passed.
- All merges passed.
- Tests passed.

Files changed:
- src/api.py
- src/auth.py
- tests/test_api.py
```