team-audio skill

If no argument is provided, output usage guidance and exit without spawning any agents:

Usage: /team-audio [feature or area] — specify the feature or area to design audio for (e.g., combat, main menu, forest biome, boss encounter). Do not use AskUserQuestion here; output the guidance directly.

When this skill is invoked with an argument, orchestrate the audio team through a structured pipeline.

Decision Points: At each step transition, use AskUserQuestion to present the user with the subagent's proposals as selectable options. Write the agent's full analysis in conversation, then capture the decision with concise labels. In collaborative mode, the user must approve before moving to the next step. In guided mode the pipeline advances automatically unless a step is BLOCKED; in autonomous mode it runs end to end, recording each step outcome via logdecision. Decisions in automationalwaysask categories (isalwaysaskcategory helper) always prompt regardless of mode. See .claude/docs/automation-modes.md.

Phase 0: Resolve Config

!bash "${CLAUDESKILLDIR}/../../hooks/yaml-helper.sh" resolveconfig --keys reviewmode,automation,team.size

Resolved above — use as-is; --review overrides review_mode. No block → defaults in .claude/docs/config-resolution.md.

review_mode sets gate depth:

• full — spawn all director and lead gates as described
• lean — skip director gates unless they are PHASE-GATE type (CD-PHASE-GATE, TD-PHASE-GATE, PR-PHASE-GATE, AD-PHASE-GATE)
• solo — skip all director gate spawning entirely; run the skill without any agent gates

automation drives the Decision Points note above. See the Decision Points note above and .claude/docs/automation-modes.md for how each mode changes pipeline behavior.

team.size: which agents are active (orthogonal to review_mode gate-depth and workflow docs).

Directors (CD/TD/PR) still spawn at phase gates regardless of size; a non-core agent needed at individual routes through the nearest active core agent with an informational note. "Phase gate" means any phase that ends in an AskUserQuestion decision point before the pipeline advances — not every phase. Apply the test literally: if the phase below has no decision point, it is not a gate, and an agent restricted to "phase gates only" is not spawned for it. This active-set scoping applies throughout the pipeline below: any phase that names an agent outside the active set routes through the nearest core agent rather than spawning it.

• individual (default): sound-designer only. Other agents consulted via the sound-designer, not spawned separately.
• small: + audio-director + technical-artist.
• studio: + localization-lead + per-system audio reviewers.

Announce the active set before Step 1 — never let the collapse be silent. Before spawning anything, state in one line which agents this run will actually spawn, and which the pipeline below names but will not spawn at the resolved team.size. For example:

Active set (team.size: ): .

Not spawned this run: — consulted

through . Raise team.size (or modes.rigor) to widen.

Fill it from the team.size list directly above and the agents this file's own pipeline names — not from an example. Both sets differ per orchestrator.

The pipeline below reads as a multi-agent fan-out and at the shipped default it is one or two agents — team-release names eight and runs one, team-narrative names six across five phases and runs writer alone. The collapse is correct: team.size is rigor-fronted and the narrow default is the token lever, measured at roughly 10x. What was wrong is that nothing said so, so a reader could not distinguish a correctly-collapsed run from a broken pipeline, and the per-agent "routes through the nearest core agent with an informational note" rule above fires at routing time and never states the shape of the run as a whole.

This is the same rule as the skipped-check reporting elsewhere in this file: a constraint that is enforced but never surfaced is indistinguishable, to the person reading the output, from one that was never enforced.

main menu, forest biome, boss encounter).

1. Read the argument for the target feature or area (e.g., combat,

1. Gather context:

• Read relevant design docs in design/gdd/ for the feature
• Read the sound bible at design/gdd/sound-bible.md if it exists
• Read existing audio asset lists in assets/audio/
• Read any existing sound design docs for this area

How to Delegate

Use the Agent tool to spawn each team member as a subagent:

• subagent_type: audio-director — Sonic identity, emotional tone, audio palette
• subagent_type: sound-designer — SFX specifications, audio events, mixing groups
• subagent_type: technical-artist — Audio middleware, bus structure, memory budgets
• subagent_type: [primary engine specialist] — Validate audio integration patterns for the engine
• subagent_type: gameplay-programmer — Audio manager, gameplay triggers, adaptive music

Brief each agent — do not dump context. Read the shared inputs once and pass a distilled brief inline: the lines each agent actually needs, never a file path for a document you have already read (an agent handed a path re-reads the whole file). Pass a path only for a document you have not read and only that agent needs.

End every agent prompt with a return contract: "Write your full output to [path] — that named path is your write authorisation under the bounded exception below, so write it without a separate approval prompt. Return only (1) the path written, (2) a ≤5-bullet summary of decisions, (3) any BLOCKED/CONCERNS items, one line each. Do not restate the documents you read." Without it, an agent returns everything it read back into this session.

Why this does not violate the Collaboration Protocol. CLAUDE.md requires an agent to ask "May I write this to [filepath]?" before Write/Edit. A subagent spawned here writes without asking, and that is a deliberate, bounded exception rather than an oversight — the same call already made for consistency-check appending to active.md. The exception holds only when all three are true: (1) the path is one you named in the prompt, so the user approved the destination when they approved the phase; (2) it is a new artifact under production/, docs/ or tests/, never an edit to existing source or config; (3) the phase that produced it is itself gated by an AskUserQuestion before the pipeline advances. Outside those three, the agent must ask. Do not "fix" this by asking per subagent — a prompt per agent per phase makes an orchestrator unusable, which is why the exception exists.

1. Orchestrate the audio team in sequence:

Step 1: Audio Direction (audio-director)

Spawn the audio-director agent to:

• Define the sonic identity for this feature/area
• Specify the emotional tone and audio palette
• Set music direction (adaptive layers, stems, transitions)
• Define audio priorities and mix targets
• Establish any adaptive audio rules (combat intensity, exploration, tension)

Step 2: Sound Design and Audio Accessibility (parallel)

Spawn the sound-designer agent to:

• Create detailed SFX specifications for every audio event
• Define sound categories (ambient, UI, gameplay, music, dialogue)
• Specify per-sound parameters (volume range, pitch variation, attenuation)
• Plan audio event list with trigger conditions
• Define mixing groups and ducking rules

Spawn the accessibility-specialist agent in parallel to:

• Identify which audio events carry critical gameplay information (damage received, enemy nearby, objective complete) and require visual alternatives for hearing-impaired players
• Specify subtitle requirements: which audio events need captions, what text format, on-screen duration
• Check that no gameplay state is communicated by audio alone (all must have a visual fallback)
• Review the audio event list for any that could cause issues for players with auditory sensitivities (high-frequency alerts, sudden loud events)
• Output: audio accessibility requirements list integrated into the audio event spec

Step 3: Technical Implementation (parallel)

Spawn the technical-artist agent to:

• Design the audio middleware integration (Wwise/FMOD/native)
• Define audio bus structure and routing
• Specify memory budgets for audio assets per platform
• Plan streaming vs preloaded asset strategy
• Design any audio-reactive visual effects

Spawn the primary engine specialist in parallel (-specialist derived from engine.name — Godot→godot-specialist, Unity→unity-specialist, Unreal→unreal-specialist; fall back to the Primary line of ## Engine Specialists in .claude/docs/technical-preferences.md) to validate the integration approach:

• Is the proposed audio middleware integration idiomatic for the engine? (e.g., Godot's built-in AudioStreamPlayer vs FMOD, Unity's Audio Mixer vs Wwise, Unreal's MetaSounds vs FMOD)
• Any engine-specific audio node/component patterns that should be used?
• Known audio system changes in the pinned engine version that affect the integration plan?
• Output: engine audio integration notes to merge with the technical-artist's plan

If no engine is configured, skip the specialist spawn. Record Engine validation: NOT ASSESSED — no engine configured (engine.name unset in project.yaml) in this run's output. A skipped check that says nothing is indistinguishable from a check that passed; the reader cannot tell engine guidance was never sought.

Step 4: Code Integration (gameplay-programmer)

Spawn the gameplay-programmer agent to:

• Implement audio manager system or review existing
• Wire up audio events to gameplay triggers
• Implement adaptive music system (if specified)
• Set up audio occlusion/reverb zones
• Write unit tests for audio event triggers

1. Compile the audio design document combining all team outputs.

NOT one of the three directories the bounded write exception covers (production/, docs/, tests/), so a sub-agent handed this path must prompt, and one has done exactly that. Do not resolve that by widening the exception. Instead, follow the same pattern team-level uses: you already hold every sub-agent's output, so compile the document yourself and ask directly via AskUserQuestion — "May I write the audio design to design/audio/audio-[feature].md?" — then write it on approval. Sub-agent working artifacts stay under production/ where the exception does reach them.

1. Save to design/audio/audio-[feature].md — but ask first. design/ is

Note: If design/audio/ does not exist, the sub-agent writing the document should create it (the directory will be created automatically when the file is written).

implementation tasks, and any open questions between team members.

1. Output a summary with: audio event count, estimated asset count,

Verdict: COMPLETE — audio design document produced and team pipeline finished.

If the pipeline stops because a dependency is unresolved (e.g., critical accessibility gap or missing GDD not resolved by the user):

Verdict: BLOCKED — [reason]

File Write Protocol

All file writes (audio design docs, SFX specs, implementation files) are delegated to sub-agents spawned via Agent. Those writes follow the bounded exception documented above under "Why this does not violate the Collaboration Protocol" — the path is one you named, the artifact is new under production/, docs/ or tests/, and the phase is gated by an AskUserQuestion. A sub-agent does not prompt per write inside those bounds; outside them it must ask. This orchestrator does not write files directly.

Next Steps