Kickoff

---
name: kickoff
description: Launch a collaborative team meeting using agent teams. Use when the user wants deep multi-perspective analysis, adversarial review, debugging with competing hypotheses, or any task where agents should debate and converge rather than work independently.
argument-hint: "[team name] on [topic]"
disable-model-invocation: true
---

# Kickoff: $ARGUMENTS

You are the team lead for a collaborative agent team meeting. Unlike skills that delegate to independent subagents, kickoff uses Claude Code's agent teams feature — teammates share a task list, message each other directly, and challenge each other's findings.

## Phase 0 — Team Selection

1. Parse `$ARGUMENTS` to identify the team:
   - **Named team match**: If arguments mention a team name from the "Team Meetings" section in CLAUDE.md (e.g., "Discovery Sprint", "Build & QA", "Ship & Launch"), use that team's members.
   - **Agent mentions**: If arguments include `@agent` references (e.g., `@engineer @qa on [topic]`), assemble an ad-hoc team with those agents.
   - **Topic-based inference**: If arguments describe a task without naming a team, infer the best fit:
     - Research, exploration, idea validation → Discovery Sprint
     - Code review, debugging, architecture → Build & QA
     - Launch prep, deployment, announcements → Ship & Launch
   - **Ambiguous**: Propose your best-fit team and let the CEO confirm or adjust.

2. If `$ARGUMENTS` includes a file path or reference, read it for context to pass to teammates.

3. Present to the CEO via AskUserQuestion:
   ```
   I'll assemble [team name] to work on [topic]:
   - @[agent1]: [their focus for this meeting]
   - @[agent2]: [their focus for this meeting]
   - @[agent3]: [their focus for this meeting]

   They'll collaborate — sharing findings, challenging assumptions, and
   converging on a recommendation.

   Note: This assembles your full team for collaborative discussion —
   takes longer and uses more resources, but produces deeper analysis.
   ```

   Options: "Yes, start the meeting" / "Adjust the team" / "Use [lifecycle skill] instead" (suggest the faster alternative — e.g., `/discover` for research, `/review` for code review)

## Phase 1 — Spawn Agent Team

On CEO approval, create the agent team:

**Teammate setup** — for each team member:

1. Read the agent's role file (`agents/[agent].md`) for their system prompt and capabilities.

2. Write a spawn prompt that includes:
   - The agent's role description and expertise
   - The topic and any file context (spec content, code to review, bug report, etc.)
   - Collaborative instructions: "You are in a team meeting with [other teammates]. Share your findings with them. Challenge assumptions you disagree with. Build on their insights. Your goal is to converge on the best recommendation as a team, not just produce your own independent analysis."

3. Use Sonnet for teammates by default (balances capability and cost).

**Task list** — create a shared task list based on the meeting's purpose. Aim for 5-6 tasks per teammate. Examples:

For a Discovery Sprint:
- Research competitive landscape and existing solutions
- Assess market size, pricing opportunities, and unit economics
- Evaluate technical feasibility and architecture approach
- Identify top risks and potential blockers
- Challenge each other's findings and draft consolidated recommendation

For an adversarial code review:
- Review for security vulnerabilities and data exposure
- Review for performance issues and scalability
- Review for edge cases and error handling
- Challenge each other's findings — debate severity and impact
- Draft prioritized findings with consensus severity ratings

**Monitoring** — while teammates collaborate:
- Wait for all teammates to finish before compiling results (do not start implementing or writing the summary yourself)
- Intervene only if a teammate goes off-topic, appears stuck, or the CEO sends a message
- If a task appears stuck (teammates sometimes fail to mark tasks complete), nudge the teammate

## Phase 2 — Compile & Present

When all teammates have finished:

1. Compile findings into a structured report:

   ```
   ## Kickoff Report: [topic]

   ### Consensus
   [What the team agreed on — the strongest, most defensible conclusions]

   ### Debate Points
   [Where agents disagreed, with each side's reasoning. Highlight which
   argument was stronger and why]

   ### Key Findings
   - **@[agent1]**: [Top insight from their perspective]
   - **@[agent2]**: [Top insight from their perspective]
   - **@[agent3]**: [Top insight from their perspective]

   ### Recommendation
   [The team's collective recommendation — what the CEO should do next]

   ### Dissent
   [If any agent strongly disagrees with the recommendation, note it here
   with their reasoning. The CEO deserves to see minority opinions.]
   ```

2. Clean up the team.

3. Suggest the next step based on what was discussed:
   - Discovery kickoff → `/solopreneur:spec`
   - Code review kickoff → fix issues or `/solopreneur:ship`
   - Debug kickoff → implement the fix
   - Launch kickoff → `/solopreneur:ship`
   - Ad-hoc → suggest the most relevant next action