Skip to content
Skills Library
AI & agents · Automation

implement-milestone

/implement-milestone

This skill should be used when the user asks to 'implement milestone', 'implement all tasks', 'implement m5', or when working on an entire milestone's worth of tasks. Orchestrates milestone-level implementation across task groups with agent teams.

Repository
engy ↗
Licence
MIT
Last repository change
26.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
2
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 26.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

This skill should be used when the user asks to 'implement milestone', 'implement all tasks', 'implement m5', or when working on an entire milestone's worth of tasks. Orchestrates milestone-level implementation across task groups with agent teams.

Triggers from the description

implement milestoneimplement all tasksimplement m5
Original author description

This skill should be used when the user asks to 'implement milestone', 'implement all tasks', 'implement m5', or when working on an entire milestone's worth of tasks. Orchestrates milestone-level implementation across task groups with agent teams.

How it works

  1. MCP Tools
  2. Core Principle
  3. Workflow
  4. Key Principles
  5. Additional Resources
  6. Flow Position
Original SKILL.md headings · 163 lines, 1,493 words
SKILL.md preview
---
name: implement-milestone
description: "This skill should be used when the user asks to 'implement milestone', 'implement all tasks', 'implement m5', or when working on an entire milestone's worth of tasks. Orchestrates milestone-level implementation across task groups with agent teams."
---

# Milestone Implementation Orchestrator

Orchestrate the implementation of an entire milestone by dispatching one agent per task. The orchestrator NEVER writes implementation code — it only gathers context, dispatches agents, validates results, and updates task status. Each agent uses `/engy:implement` for per-task TDD flow.

## MCP Tools

- `listTasks(projectId, milestoneRef, taskGroupId)` — find tasks for the milestone
- `listTaskGroups(milestoneRef)` — task groups within the milestone
- `updateTask(id, status)` — mark tasks `in_progress` / `done`
- `getTask(id)` — full task details (description, plan content)
- `getProjectDetails(projectId)` — project paths (`specDir`, `projectDir`)

Use MCP to discover paths and task relationships, then Read/Glob/Grep for content.

## Core Principle

**The orchestrator is a pure coordinator.** It gathers context, plans execution order, dispatches team members, verifies their results, and updates task status. It NEVER writes or modifies implementation code itself. All implementation work happens inside subagents.

## Workflow

### Step 1: Gather Context

1. `listTaskGroups(milestoneRef)` — get all task groups for the milestone.
   > **TG references in prompts** (e.g. "M1 TG2") use the `numInMilestone` field returned by `listTaskGroups`,
   > NOT the DB `id`. To resolve "TG2", find the group where `numInMilestone === 2` within the milestone's groups.
2. **Scope task fetching to what you'll dispatch — never fetch the entire milestone when only one task group is requested.** If a specific task group was requested, use `listTasks(milestoneRef, taskGroupId)` to fetch only that group's tasks. Otherwise use `listTasks(milestoneRef)` for all tasks. The default compact rows carry only `id`, `title`, `status` and `blockedBy`. Call `getTask(id)` only for the tasks you'll actually dispatch.
3. Look for the milestone plan doc: `Glob("{specDir}/milestones/m{N}-*.plan.md")`, with `specDir` from `getProjectDetails`. Read it if found — this is the primary requirements source.
4. If no plan doc exists, read `{specDir}/spec.md` for overall context.

### Step 2: Discover Validation Commands

Read the project's **CLAUDE.md** to find all explicit validation and testing instructions. Extract two levels:

1. **Lightweight validation** — the commands each subagent must run before returning (build, lint, changed tests). Derive this from CLAUDE.md's quality gates and testing sections.
2. **Full validation** — the complete validation command set for end-to-end checks after each task group completes and after all tasks complete. This is whatever CLAUDE.md specifies as the pre-commit or CI gate.
3. **Cross-package checks** — when tasks span multiple packages in a monorepo, include the repo-wide type or build check (run at the root, or across dependent packages) in both lightweight and full validation — not just the package being modified. A change can compile inside its own package and still break a consumer.

### Step 3: Plan Execution Order

1. Map task group dependencies (a group is blocked if any of its tasks have `blockedBy` pointing to tasks in another group).
2. **Task groups execute sequentially** — process one group at a time in dependency order.
3. **Within each task group**, identify which tasks can run in parallel:
   - Tasks with no `blockedBy` dependencies on other tasks in the same group → **candidates for parallel** dispatch.
   - Tasks with `blockedBy` dependencies within the group → **serialized** in dependency order after their blockers complete.
4. **File overlap check (mandatory before parallel dispatch):** For each parallel wave, verify that no two tasks modify the same files. Check task descriptions, plan sections, and affected component lists. If file overlap exists, serialize the overlapping tasks or ask the user to confirm parallel execution.
5. Skip task groups where all tasks are marked `done`.
6. For groups with `in_progress` tasks, check existing work via `git status` and `git diff` before re-dispatching.

### Step 4: Process Each Task Group

For each task group, in sequence:

#### 4a. Dispatch Team Members

Mark all tasks in the group as `in_progress` via `updateTask(id, status: "in_progress")`.

**One agent per task.** For each task, spawn an agent with:
- Task title, description, and acceptance criteria
- Relevant section of the plan doc
- Validation commands to run before returning (from Step 2)
- File paths and pattern references relevant to the task
- Explicit instruction to commit changes before returning. CRITICAL: do not include milestone/tg/task ids in task title or description

**Parallelism:** If multiple tasks in the group have no mutual `blockedBy` dependencies and pass the file overlap check (Step 3.4), spawn them as concurrent team members in a **single message with multiple Agent tool calls**. Dependent tasks wait until their blockers complete, then get dispatched.

**Never use worktree isolation** (`isolation: "worktree"`) for parallel agents. Use regular agents with explicit file-ownership lists instead. Each agent receives a list of files it owns (may modify) and files it must not touch.

**Agent prompt template:**

```
Implement the following task using /engy:implement:

Task: {task title}
Description: {task description}

Plan context:
{relevant plan section}

Files you OWN (may create/modify):
{list of files this agent is responsible for}

Files you must NOT modify:
{list of files owned by other parallel agents or out of scope}

Before returning, you MUST:
1. Run these validation commands and fix any issues:
   {lightweight validation commands from Step 2}
2. Commit your changes with a descriptive commit message.
3. Report back: what you implemented, what you committed, any issues encountered.

CRITICAL safety rules:
- Do NOT modify files outside your ownership list.
- NEVER run git stash, git reset, or any destructive git command.
- If something breaks on files you didn't touch, ignore it and report back.
```

#### 4b. Process Results

A returning agent's summary is a rung-1 claim — it says what the agent believes, not what happened.
Confirm it against the repo before you trust it.

As each team member returns:

1. Confirm the commit exists yourself: `git log` for the SHA and `git show --stat` for the files it
   actually touched. An agent reporting success with no commit is a failure, not a success.
2. Read the diff. It is yours now — you own what lands, and reviewing it is the reason to dispatch
   rather than implement.
3. Mark the task `done` via `updateTask(id, status: "done")` only after both.
4. If the agent reports failure, or its claim does not survive step 1 or 2, decide: dispatch a fix
   agent or escalate to the user. Dispatch a **fresh** agent with the consolidated scope rather than
   messaging the original one — a resumed agent quietly drops directives, so its second "done" is
   less trustworthy than its first.

#### 4c. Post-Group Validation

After all tasks in a group complete, run the **full validation gate** (discovered in Step 2) before proceeding to the next group. This catches cross-task integration issues early. If validation fails, dispatch fix agents for the failing issues before moving on.

### Step 5: Final Validation

After all task groups complete:

1. Run the **full validation commands** discovered in Step 2. Read complete output, verify explicitly — never assume success.
2. If issues are found:
   - **Batch related issues** (e.g., issues in the same file or same feature area) into groups.
   - Dispatch one fix agent per batch. Each fix agent receives: the issues to fix, validation commands, and instruction to commit before returning.
   - Fix agents follow the same validate-and-commit contract as implementation agents.
3. **Circuit breaker:** after 3 failed validation/fix cycles, stop and report to user with diagnostics (what failed, what was attempted, suggested next steps).

### Step 6: Report

Present a summary to the user:

1. **Tasks completed** — list of tasks and the commit SHAs you confirmed.
2. **Validation results** — each gate with its verdict (VERIFIED / NOT VERIFIED / INCONCLUSIVE), evidence rung, and artifact.
3. **Follow-ups** — remaining issues, deferred feedback, and anything left INCONCLUSIVE.

## Key Principles

- **Orchestrate, never implement.** The orchestrator dispatches agents — it never writes code.
- **One agent per task.** Each task gets its own dedicated agent.
- **Task groups sequential, tasks parallel.** Groups run in order; independent tasks within a group run concurrently as team members.
- **Subagents validate and commit.** Each agent runs validation commands and commits before returning.
- **Commit before done.** Task status is only set to `done` after a successful commit.
- **Evidence before claims.** Grade each claim on the ladder in `../implement/references/evidence-ladder.md` and say where it stopped. A subagent's "done" is rung 1 until you check the commit and diff.
- **Fresh context per agent.** Each team member gets a complete, self-contained task description with validation commands. Never assume shared context.
- **No worktree isolation.** Never use `isolation: "worktree"` for parallel agents — use regular agents with explicit file-ownership lists.
- **No destructive git.** Agents must never run `git stash`, `git reset`, or other destructive git commands.
- **Validate after each group.** Run the full validation gate after each task group, not just at the end.

## Additional Resources

### Reference Files

- For parallelization criteria, agent context requirements, and conflict prevention, see [references/agent-team-coordination.md](references/agent-team-coordination.md)
- For grading a claim and choosing a verdict, see [../implement/references/evidence-ladder.md](../implement/references/evidence-ladder.md)

## Flow Position

**Previous:** `validate-plan` | **Next:** `review`

When all tasks are complete and passing, proceed with `/engy:review` for a final code review of all changes.
Files in this package (2)
  • SKILL.md 10 KB
  • references/agent-team-coordination.md 2 KB

Versions

The database has no other skills named implement-milestone.

Database snapshot: 13.11.2026 · package version 49d882902283 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 1 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 96milestone-review
    生成全面的里程碑进度审查,包括功能完整性、质量指标、风险评估和启动/不启动建议。在里程碑检查点或评估里程碑截止日期的准备情况时使用。
  • 100milestone-plan
    This skill should be used when the user asks to 'plan my project', 'plan milestones', 'break down into tasks', or 'create tasks for milestone'. Plans spec milestones in detail — task groups, tasks, dependencies, and priorities.
  • 100milestone-next
    Milestone 推进循环:更新 master → 体检刚合入的 Feature → 按需调研/审查 → 修订 Milestone(用户拍板)→ 派发下一批 Feature prompt(能并行就并行)。 里程碑无关(M7/M8/... 通用)。用户说"推进 milestone"、"看下一步"、 "/milestone-next" 时使用。决策点一律回用户拍板,不自动决策。
  • 100milestone-review
    Conducts a structured milestone review analyzing delivered features, metrics, blockers, and readiness for the next phase. Use when completing a milestone or when the user mentions milestone review or phase gate.
  • 100release-readiness
    WAY 12 — go / no-go report for a release or milestone. Use when the user says "release check", "go no go", "are we ready to release", "release readiness" with a milestone or version.
  • 95complete-milestone
    Orchestrate a cliban milestone end-to-end: one agent per ticket, dependency waves, isolated worktrees, integrated onto a milestone branch. Use when asked to run, drive, orchestrate, or complete a whole milestone.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.