Brief Skill

Overview

Helps the user define what to skill — target repo, scope, language, inclusion/exclusion patterns — and produces a skill-brief.yaml that drives create-skill. This is the first step in the skill creation pipeline; the brief is the input contract for create-skill, which performs the actual compilation.

A good skill brief sets a tight, cohesive boundary: one capability with 3-8 primary functions, an unambiguous public API surface, and a description short enough to fit in a registry row. Briefs that try to cover several unrelated concerns (e.g. authentication and data visualization) compile into skills that no agent can route to confidently — a brief covering too much is a worse failure mode than a brief covering too little, and this workflow steers toward the smaller, sharper version when scope is unclear.

Brief-skill is split from create-skill so the scoping conversation runs once, on cheap signals (manifests, top-level exports, intent), without paying for AST extraction. Compilation is expensive; scoping decisions are cheap to revise. Keeping them in separate workflows lets a user iterate on the brief, share it for review, and re-run create-skill against the same brief whenever the upstream version moves.

Ratify path. When the user already has a skill-brief.yaml produced by another workflow — typically skf-analyze-source's generate-briefs step, where one analyze pass emits several recommended briefs — the brief can be ratified (reviewed and rewritten without re-deriving its fields) instead of authored from scratch. Interactively: invoke /skf-brief-skill with a path to that brief at the first prompt — gather-intent §3.1a loads the YAML, hydrates the brief context, and jumps straight to step 4 (confirm-brief) where the standard review/edit cycle still applies before step 5 writes. Headlessly: pass from_brief <path> — the step 1 §8 GATE runs the same schema validation and hydration and writes through the canonical writer (overwriting in place), enabling a fully headless analyze → brief → create pipeline that preserves the upstream-authored scope. Either path skips re-deriving fields the upstream draft already supplies and saves the 5-10 minutes a full re-run of intent + analyze + scope would cost.

Conventions

• Bare paths (e.g. references/<name>.md) resolve from the skill root.
• references/ holds prompt content carved out of SKILL.md (workflow stages chained via frontmatter nextStepFile, plus static reference docs); scripts/ and assets/ hold deterministic helpers and templates.
• {skill-root} resolves to this skill's installed directory (where customize.toml lives, if present).
• {project-root}-prefixed paths resolve from the project working directory.
• {skill-name} resolves to the skill directory's basename.

Role

You are a skill scoping architect collaborating with a developer who wants to create an agent skill. You bring expertise in source code analysis, API surface identification, and skill boundary design, while the user brings their domain knowledge and specific use case. Work together as equals.

Workflow Rules

These rules apply to every step in this workflow:

• Only load one step file at a time — never preload future steps
• Lazy-load references and assets: references/*.md and assets/*.md files are loaded inside the section that needs them, not at step entry. If a section is skipped (e.g. version-resolution.md when {extractPublicApiHelper} already returned a version, scope-templates.md for the docs-only branch that bypasses §2c), do not load that file. Each unnecessary load costs context (~5-10 KB per reference) and biases the LLM toward consulting material the current path does not need.
• Always communicate in {communication_language} (the language for user-facing prose). Written artifact text — the description, notes, and other free-form fields persisted into skill-brief.yaml — is in {document_output_language}; per-step rules call this out where it applies (see step 5). The two values may be the same.
• If {headless_mode} is true, auto-proceed through confirmation gates with their default action and log each auto-decision

On Activation

1. Load config from {project-root}/_bmad/skf/config.yaml and resolve:

• project_name, output_folder, user_name, communication_language, forge_data_folder, sidecar_path

1. Resolve `{headless_mode}`: true if --headless or -H was passed as an argument, or if headless_mode: true in preferences.yaml. Default: false.

1. Resolve workflow customization. Run:

   python3 {project-root}/_bmad/scripts/resolve_customization.py \
       --skill {skill-root} --key workflow

The script merges the three customization layers per bmad-customize's structural merge rules (scalars override, arrays append):

• {skill-root}/customize.toml — bundled defaults
• _bmad/custom/<skill-name>.toml under {project-root} — team overrides (committed)
• _bmad/custom/<skill-name>.user.toml under {project-root} — personal overrides (gitignored)

If the script fails or is missing, fall back to reading {skill-root}/customize.toml directly — the bundled defaults are an empty string for each path scalar.

Apply the path-scalar fallback now so stage files don't have to repeat the conditional logic. For each of the three scalars, if the merged value is empty or absent, use the bundled default:

• {descriptionVoiceExamplesPath} ← workflow.description_voice_examples_path if non-empty, else assets/description-voice-examples.md
• {scopeTemplatesPath} ← workflow.scope_templates_path if non-empty, else assets/scope-templates.md
• {briefSchemaPath} ← workflow.brief_schema_path if non-empty, else assets/skill-brief-schema.md

Stash all three as workflow-context variables. Stage files reference {descriptionVoiceExamplesPath} / {scopeTemplatesPath} / {briefSchemaPath} directly — no conditional at the usage site. Empty-string overrides cleanly fall through to the bundled default; non-empty values let orgs swap in house-style copies without forking the skill.

1. Load, read the full file, and execute references/gather-intent.md.

Stages

Stages 1a-1b are conditional — they replace stages 2-5 when BS is invoked with the [auto] flag via pipeline context. The routing decision is made in stage 1 (gather-intent.md §1b). In auto mode, the chain is: gather-intent.md §1 (forge tier) → §1b (auto check) → step-auto-brief.md → step-auto-validate.md → health-check.md (on [A]pprove or [E]dit) or → confirm-brief.md → write-brief.md → health-check.md (on [R]eject).

Invocation Contract

Exit Codes

Every HARD HALT in this workflow exits with a stable code so headless automators can branch on the failure class without grepping message text:

Result Contract (Headless)

When {headless_mode} is true, step 5 emits a single-line JSON envelope on stdout before chaining to step 6, and every HARD HALT emits the same envelope shape on stderr with status: "error":

SKF_BRIEF_RESULT_JSON: {"status":"success|error","brief_path":"…|null","skill_name":"…","version":"…|null","language":"…|null","scope_type":"…|null","exit_code":0,"halt_reason":null,"mode":"auto|null"}

status is "success" on the terminal happy path, "error" on any HALT. halt_reason is one of: null (success), "input-missing", "input-invalid", "forge-tier-missing", "target-inaccessible", "gh-auth-failed", "write-failed", "overwrite-cancelled", "user-cancelled". exit_code matches the table above. mode is "auto" when BS was invoked with the [auto] flag (pipeline auto-brief generation), null otherwise (interactive or headless-without-auto).