Mission Brief

mission-brief

What this skill does

mission-brief takes a feature description, structures it into a Mission Brief (goal, constraints, success criteria), generates an ordered step list with prompts, and executes those steps — each step dispatched to a subagent whose prompt triggers the installed SDD skills. No YAML workflow files, no per-framework profiles, no profile detection. The step prompts use canonical SDD terminology (specify, plan, implement, converge) that works with any SDD skill set — model-invoked skills auto-trigger, command-based frameworks match by filename, and if neither exists the subagent executes directly.

When to use

• "Build this feature end to end": you give a description, mission-brief

composes the pipeline and runs specify → plan → implement ↔ converge.

• You want a converge loop with a circuit breaker and an audit trail.
• You want to resume an interrupted mission across sessions

(mission-brief --resume).

• You want to run unattended across sessions (mission-brief --async).

When NOT to use

• A single small edit — just do it; a mission is overhead.
• You already have a spec and tasks and only want to implement one task —

invoke the implement skill directly.

Mission Brief template

Before generating steps, the description is structured into:

## Mission Brief

**Goal**: 
**Constraints**: 
**Non-Goals**: 
**Success Criteria**:
- 
- 
- 

The brief serves two purposes:

1. Forces explicit done-criteria upfront — feeds the converge step's

independence check (the checker verifies against these criteria).

1. Carries mission context into every step's delegation prompt so each

subagent has full context without re-reading prior steps.

Inputs

$ARGUMENTS

The text in the $ARGUMENTS block above IS your mission description — proceed with it immediately. Do not ask the user what they want to build.

Parse flags from the arguments first, then treat the remaining text as spec_description:

• --async / --sync — execution mode flag (overrides config default).
• --resume — explicit resume from state.
• Everything else — the mission description (spec_description).

If no description and not --resume: derive a best-effort description from the feature name (git branch, or the last state's feature). If --resume and no state: report "No interrupted mission found" and stop.

Feature name derivation: slugify the description to lowercase-hyphenated, drop stop words (a, an, the, new, to, with, for, add, fix, update). Example: "add a new react dashboard with telemetry" → react-dashboard-telemetry. If .adlc/workflow/runs/ already contains a dir with that name, append -2, -3, etc.

Flow

> All paths are relative to the current working directory (the project > root where the agent operates). Do not look in subdirectories for config or > state unless explicitly stated.

Phase 0 — Configuration

1. mkdir -p .adlc/workflow (and .adlc/workflow/tmp, .adlc/workflow/runs).
2. If .adlc/workflow/workflow-config.yml does not exist, copy it from the

skill's config-template.yml (located alongside this SKILL.md).

1. Read .adlc/workflow/workflow-config.yml. Defaults if fields are absent:

workflow:
  execution: sync            # sync | async
  supervision: gated         # gated | hybrid | autonomous
  max_iterations: 5
  max_spec_corrections: 2
  circuit_breaker: 3
  quality_threshold: null    # optional 0-100, blocks DONE below threshold
  # models: { strong: "...", fast: "..." }   # optional

Resolve the effective execution mode: --async/--sync flag > config execution > sync. If --async and supervision is gated/hybrid: warn ("async forces ungated; running autonomous") and treat as autonomous for this run.

Phase 1 — Resume check (--resume only)

> ` = .adlc/workflow/runs//` (defined in Phase 4, but > referenced here for the completed-mission check).

If --resume was passed:

1. Read .adlc/workflow/.mission-state.json.
2. If /mission-log.json exists → report "Mission already

completed for feature X. Audit trail: …" → stop.

1. If state exists with non-empty completed_steps → resume: load the step

list from state.steps, skip to Phase 5 (Execute) at the first incomplete step.

1. If no state → report "No interrupted mission found. Run

mission-brief \"\" to start one." → stop.

If --resume was NOT passed and a state file with non-empty completed_steps exists: ask — "An interrupted mission for feature X exists (N/M steps done). Run mission-brief --resume to continue, or confirm to start fresh (this discards the state)." Do not silently clobber.

Phase 2 — Mission Brief

Structure spec_description into the Mission Brief template:

1. Goal: extract the core objective in one sentence.
2. Constraints: infer tech stack, limitations, and requirements from the

description and the project context (check package.json, go.mod, language files, existing specs). If unclear, leave a placeholder and mark it for the user to fill.

1. Non-Goals: infer 1–2 reasonable boundaries or features that should be

explicitly excluded to keep implementation focused and simple. If none can be inferred, mark as "None".

1. Success Criteria: derive 2-5 measurable outcomes. If the description is

vague, generate reasonable defaults based on the feature type and mark them as "suggested — edit if needed".

Present the brief to the user:

• sync + gated/hybrid → show the brief and ask for confirmation or edits

before proceeding.

• sync + autonomous → if Success Criteria are "TBD" or empty, STOP:

"Autonomous mode requires checkable done-criteria." Otherwise proceed without confirmation.

• --async → proceed without confirmation (autonomous, ungated).

Store the brief in .mission-state.json.brief.

Phase 3 — Route classification & optional phases

Classify into spec / change / quick:

| Route | When | Steps | |---|---|---| | spec | New feature, greenfield, "add/create/build" | brainstorm? → specify → clarify? → plan → tasks → analyze? → implement↺converge → trace? | | change | Modification, brownfield, "fix/update/refactor" | specify → implement↺converge | | quick | Small task, trivial, "just/quick/simple" | implement only (full brief as input) |

For spec route only, assess optional-phase candidates (hands-off, recorded in state; the user approves each at a runtime gate if supervision is gated/hybrid):

| Phase | Candidate when | |---|---| | brainstorm | prompt is architectural/ambiguous ("design", "approach", "compare", "how should we", multiple viable solutions) | | clarify | success criteria are vague / constraints missing | | analyze | route is spec (symmetric) | | trace | prompt mentions persistence, audit, traceability, compliance |

Phase 4 — Command discovery & generate step list

4a. Command/skills discovery

Read references/agent-integrations.md (alongside this SKILL.md). For each agent directory listed in the table, check if it exists in the project root. Record discovered directories in state:

"discovered": {
  "skills_dirs": [".claude/skills"],
  "commands_dirs": [{"dir": ".opencode/commands", "ext": ".md"}]
}

This discovery is done once at generation time and reused on --resume. See the reference file for the full algorithm.

4a.1 Local skills inventory (universal skill routing)

After discovering skills directories (4a), build an inventory of every installed skill across all skills_dirs. For each // subdirectory that contains a SKILL.md:

1. Read the SKILL.md frontmatter (YAML between --- fences).
2. Extract name and description (fall back to the directory name if

frontmatter is missing or unparseable).

1. Record an entry in discovered.local_skills:

"discovered": {
  "skills_dirs": [".claude/skills"],
  "commands_dirs": [{"dir": ".opencode/commands", "ext": ".md"}],
  "local_skills": [
    {"name": "tdd", "path": ".claude/skills/tdd", "description": "Test-driven development with red-green-refactor..."},
    {"name": "grill-me", "path": ".claude/skills/grill-me", "description": "Get relentlessly interviewed about a plan..."},
    {"name": "code-review", "path": ".claude/skills/code-review", "description": "Two-axis review of the diff..."}
  ]
}

This inventory is vendor-agnostic — it captures skills from any source (mattpocock/skills, addy osmani/agent-skills, superpowers, custom team skills, or any Agent-Skills-standard repository). The inventory is passed to every subagent at dispatch time (Phase 5) so the LLM decides which skill fits the current step — no hard-coded phase-to-skill mapping tables.

4b. Generate the step list

Generate an ordered list of steps based on the route and optional-phase candidates. Each step is a structured object stored in state.steps:

{
  "id": "specify",
  "phase": "specify",
  "tier": "strong",
  "prompt": "Write a feature specification for the goal below. ...",
  "status": "pending"
}

The step list is the reviewable artifact — present it to the user in gated/hybrid mode before execution:

## Mission Steps

1. [specify]  (strong) Write a feature specification for: react dashboard with telemetry
2. [plan]     (strong) Break down the specification into an implementation plan
3. [tasks]    (fast)   Generate the detailed task list from the plan
4. [implement](strong) Implement the next pending task from the plan
5. [converge] (fast)   Review the implementation against the spec and success criteria
   ↺ loop 4–5 until converged (max 5 iterations, circuit breaker 3)

For quick route: single implement step with the full brief as input.

For change route: specify + implement↺converge loop (no optional phases).

For spec route: full pipeline with optional phases inserted as gated candidates.

Step prompt construction

Each step's prompt is built from three parts:

1. Phase instruction — canonical SDD terminology per phase:

| Phase | Tier | Instruction | |---|---|---| | brainstorm | strong | "Explore approaches and tradeoffs for the goal below. Consider multiple viable solutions and present a recommended design." | | specify | strong | "Write a feature specification for the goal below. Include requirements, constraints, and measurable success criteria." | | clarify | fast | "Review the specification and interview the team to resolve any vague success criteria or missing constraints." | | plan | strong | "Break down the specification into an implementation plan with ordered, verifiable tasks." | | tasks | fast | "Generate the detailed task list from the plan — each task must have exact file paths and verification steps." | | analyze | fast | "Adversarially review the plan before implementation. Challenge every non-trivial decision." | | implement | strong | "Implement the next pending task from the plan. Follow test-driven practices." | | converge | fast | "Review the implementation against the specification and success criteria. Verify independently — you are the checker, not the maker." | | trace | fast | "Document the decisions made during this feature as ADRs or a handoff document." |

2. Mission Brief context — the goal, constraints, and success criteria from Phase 2 are appended to every prompt.

3. Delegation wrapper — added by the executor at dispatch time (Phase 5). The wrapper includes discovered.local_skills so the subagent can decide which installed skill (if any) to invoke for the current step.

Phase 5 — Execute the step list

Create a todowrite list mirroring state.steps. Mark steps in completed_steps as completed. Update after every step.

Step dispatch

For each step with status: pending:

1. Emit:

```markdown ## Workflow Step:

Phase: () ```

1. If the step is a converge step (phase is converge), prepend the

independence hint to the delegation prompt: > You are grading work that another agent produced. Do NOT assume the > implementation is correct — verify against the spec independently. Try > to make each requirement fail at the primary source (run the test, check > the file, grep for the reference). You are the checker, not the maker. > > CRITICAL: Verify that NO features or implementations listed under > Non-Goals have been introduced. If any out-of-scope work was built, > report CONTINUE as your outcome signal, and list the non-goals violation > in your summary.

1. Delegate to a subagent with this prompt verbatim:

``markdown You are being invoked by the mission-brief` executor.

## Task

## Mission Brief

Goal: Constraints: Non-Goals: Success Criteria:

## Available Skills in This Workspace

The list above shows skills installed in this workspace from any source (ADLC team skills, mattpocock/skills, addy osmani/agent-skills, superpowers, or custom). Review each skill's name and description. If one matches the goal of your current task, invoke it (via the skill tool or by reading its SKILL.md inline) and use it to execute this step. If multiple skills could apply, pick the best fit. If none apply, proceed with direct execution.

## How to execute

Try these in order:

1. Skill match: If an installed skill's description matches this task,

invoke it (via skill tool or by reading its SKILL.md inline).

1. Command match: If a command file for this phase exists, read and

execute it. Look for a file whose name matches the phase (e.g., *specify*, *implement*, *converge*).

1. Direct execution: If neither exists, execute the task directly using

your available tools.

Confidence Self-Estimation: Evaluate your confidence (HIGH/MEDIUM/LOW) in this implementation or task. If you are missing critical context, have low confidence, or find the requirements ambiguous, report Confidence score: LOW (or MEDIUM) and list the specific unresolved details in your return summary.

If you found a skill or command, note its name in your summary.

Do NOT follow handoffs to other skills or commands — return your results to the executor when you finish.

Return:

1. A 1-2 sentence summary (mention which skill/command you used, if any).
2. Files changed (if any).
3. Test results (if any).
4. Outcome signal: DONE | CONTINUE | SPECCORRECTIONNEEDED.

• DONE: work is complete and verified.
• CONTINUE: more work is needed (tasks remain, review found issues).
• SPECCORRECTIONNEEDED: verification found spec-level issues that

require re-running specify. Include a spec_corrections field with the specific issues.

1. (optional) Quality score: "X/Y (Z%)" — if a verification skill ran

quality gates, report the score.

1. (optional) Gate summary: "N passed, M failed" — if quality gates were

checked, list which passed and which failed.

1. (optional) Confidence score: HIGH | MEDIUM | LOW. Self-estimated confidence in the correctness of your work.
2. (optional) Unresolved details: .

```

` is replaced with a formatted list built from discovered.local_skills`. Each entry shows the skill name, path, and description:

```markdown

• tdd (.claude/skills/tdd) — Test-driven development with red-green-refactor...
• grill-me (.claude/skills/grill-me) — Get relentlessly interviewed about a plan...
• code-review (.claude/skills/code-review) — Two-axis review of the diff...

```

If discovered.local_skills is empty, ` is replaced with: "No custom skills detected in this workspace."`

` is replaced with the discovered directories from state.discovered`:

• If commands_dirs is non-empty: "Check these locations:

`.o

…

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: tikalk
• Source: tikalk/adlc-team-skills
• License: MIT
• Homepage: https://github.com/tikalk/agentic-sdlc-12-factors

Install and usage instructions live in the source repository linked above.