---
title: "atp plan Command and the /devteam Skill"
date: "2026-04-20"
phase: implementation
category: tooling
summary: "Specified the atp plan command — a conductor session where a planner team-lead drives specialists in planning mode to emit a roadmap — along with the /devteam Claude Code skill, closing the loop between authored teams and user-facing commands."
commits: [d39dcae]
sources: ["docs/planning/2026-04-20-atp-plan-command.md"]
related: ["2026-04-17-roadmap-graph", "2026-04-19-specialist-subagent-pipeline"]
---

# atp plan Command and the /devteam Skill

## Context

By April 20 the conductor, arbitrator, `.agenticteam` bundles, and `SpecialistDispatcher` were all specified. The missing piece was a user-facing entry point: a command that ran the planning phase of the roadmap design and produced a `roadmap_id` a user could hand to `atp execute`. The `atp plan` command was the first end-to-end integration of all the preceding work.

## What changed

The `atp plan <team> [--goal TEXT]` command was specified as a single conductor session with a `plan_realizer` that dispatched each specialist's specialties in planning mode. The key design decisions:

A **planner team-lead** (authored as `team-leads/planner.md`) served as the non-interactive JSON emitter that drove the session. Unlike the interview team-lead designed for adaptive conversation, the planner's sole job was to iterate through the team's specialties and collect plan-node arrays. Teams without a `planner.md` received a clear error before any dispatch occurred.

The **plan realizer** mirrored `generic_realizer`'s shape but called each specialty's `planner_focus` field (a new optional frontmatter field on specialty markdown, falling back to `worker_focus` when absent) as the worker focus for each dispatch. The structured response from each dispatch was a JSON array of `{title, node_kind, specialist, speciality, depends_on}` entries; the conductor wrote these as `plan_node` rows and `node_dependency` edges in the arbitrator.

**Stdout** carried only the `roadmap_id` on success (one machine-parseable line). Progress streamed to stderr via the integration surface. This made `atp plan` composable: `atp execute $(atp plan devteam --goal "calculator")` would work without parsing.

The v1 scope was deliberately constrained: flat primitive nodes only (no lazy HTN compound decomposition), verifier pass skipped (roadmap structure validated by the arbitrator's FK and schema-lint constraints), sequential dispatch per specialty (parallel dispatch deferred). The `devteam/team-leads/planner.md` file was authored with role, persona, and phases sections mirroring `analysis.md`.

The `/devteam` Claude Code skill was delivered alongside the command, providing the user-facing entry point that invoked `atp plan` (and eventually `atp run`) from within a Claude Code session.

## Why

The v1 scope constraints applied **yagni** and **small-reversible-decisions** together: shipping a working flat-node planner with mock-dispatcher tests that ran without a live LLM gave an end-to-end integration path without committing to the complexity of lazy HTN decomposition, cross-team planning requests, or interactive interview flow. The `planner_focus` fallback to `worker_focus` was a zero-cost addition that prevented specialties from needing a separate authoring pass just to enable planning mode.

The `roadmap_id`-on-stdout/progress-on-stderr split was an **explicit-over-implicit** interface: callers could pipe the output without parsing human-readable progress lines, and users watching a terminal session got real-time progress without it polluting the machine-readable output.

## Impact

`atp plan` closed the April design loop: the conductor architecture's "Phase 1 — planning" scenario described on April 11 and formalized on April 17 had a concrete implementation path by April 20. The `planner_focus` specialty field and the plan realizer together defined how the `.agenticteam` schema v2 structured fields fed into actual LLM dispatch — making the bundle format immediately useful rather than a design artifact waiting for runtime support. The `/devteam` skill made all of this accessible from the Claude Code conversation without requiring users to invoke `atp` directly from a terminal.