fast-meeting

What this skill does

# Fast Meeting

Run a fully autonomous meeting with expert personas, then immediately implement the recommended solution, create a merge request or pull request, and post a French description — all without asking the user for confirmation.

## Prerequisites

- **gh** (GitHub CLI): required when the project uses GitHub — install from https://cli.github.com or `brew install gh`
- **glab** (GitLab CLI): required when the project uses GitLab — install from https://gitlab.com/gitlab-org/cli or `brew install glab`

## When to Use This Skill

Activate when the user:
- Demande un « fast meeting » ou « réunion rapide » sur un sujet
- Veut une décision ET une implémentation automatique sans interruption
- Dit « fast-meeting » ou « lance un fast meeting sur... »
- Veut qu'un sujet soit analysé, décidé et implémenté en une seule commande

## Core Principles

### 1. Full Autonomy
- The entire pipeline runs without asking any user questions
- Persona selection is automatic based on context analysis
- The best course of action is implemented immediately after the meeting
- A MR/PR is created automatically on the detected remote (GitLab or GitHub)

### 2. Speed Over Thoroughness
- The meeting is compressed: 2 rounds instead of 3 (opening + convergence)
- Personas are limited to 3-4 maximum
- The analysis is concise and action-oriented
- Implementation starts as soon as the meeting concludes

### 3. Diverse but Focused Perspectives
- Personas are auto-selected based on the subject matter
- Each persona brings a genuinely different viewpoint
- The meeting converges quickly toward an actionable recommendation

### 4. Complete Delivery
- Code changes are committed on a dedicated branch
- A MR/PR is created automatically
- The MR/PR description in French summarizes the meeting analysis and implementation

## Workflow

### Step 0: Worktree Hygiene

Before starting, clean up stale worktrees from previous meetings that may have crashed:

1. Run `git worktree prune` to remove stale worktree references
2. Check `git worktree list` — if any entries match sibling directories named `fast-meeting-*` or `fm-*`:
   - **Parallel safety:** before removing, verify the worktree directory has no active git processes (`fuser -s <worktree-path> 2>/dev/null`). If the directory is in active use, **skip it** — it belongs to another running fast-meeting
   - Only remove worktrees confirmed to be stale: `git worktree remove <path> --force`
3. Also clean up any legacy `fast-meeting/*` branches: `git branch --list 'fast-meeting/*' | xargs -r git branch -D`

This ensures a clean starting state without disrupting parallel fast-meeting runs.

### Step 1: Gather Context

1. **Read the user's prompt** — extract the topic, constraints, and goals
2. **If an issue is referenced** (GitLab `#123` or GitHub `#123`):
   - Fetch the issue details (description, labels, comments)
   - Store the issue reference (number, URL, project) for Steps 8 and 9
3. **If no issue is referenced**, note this — an issue may be created later in Step 4b
4. **If code is involved**, read relevant files to understand the current state
5. **Detect the remote repository type:**
   - Run `git remote -v` to determine if the remote is GitLab or GitHub
   - Store this for Step 8 (MR/PR creation)
6. **Identify the decision to make** — frame it as a clear one-line question

Output the decision question before proceeding. Example:
> "Question: Should we migrate the authentication system from session-based to JWT tokens?"

### Step 2: Auto-Select Personas

Automatically select 3-4 personas based on the subject matter. Use these heuristics:

| Le sujet concerne... | Personas auto-sélectionnés |
|---------------------|---------------------|
| Backend / API / base de données | SOLID Alex (Backend), Whiteboard Damien (Architecte), EXPLAIN PLAN Isabelle (DBA Oracle) |
| Frontend / UI / UX | Pixel-Perfect Hugo (Frontend), Figma Fiona (UX/UI), Sprint Zero Sarah (PO), Whiteboard Damien (Architecte) |
| Sécurité / auth / contrôle d'accès | Paranoid Shug (Sécurité), RGPD Raphaël (DPO), SOLID Alex (Backend), Whiteboard Damien (Architecte) |
| Infrastructure / déploiement / CI-CD | Pipeline Mo (DevOps), SOLID Alex (Backend), Whiteboard Damien (Architecte) |
| Données / migration / ETL | Schema JB (Data), EXPLAIN PLAN Isabelle (DBA Oracle), Whiteboard Damien (Architecte) |
| Interopérabilité / HL7 / FHIR / HPK | RFC Santiago (PO Interop), HL7 Victor (Dev Interop), SOLID Alex (Backend) |
| Legacy / Uniface / modernisation | Legacy Larry (Uniface), Whiteboard Damien (Architecte), SOLID Alex (Backend) |
| Tests / qualité / régression | Edge-Case Nico (QA), SOLID Alex (Backend), Pipeline Mo (DevOps) |
| Produit / fonctionnalité / décision UX | Sprint Zero Sarah (PO), Pixel-Perfect Hugo (Frontend), Figma Fiona (UX/UI), Whiteboard Damien (Architecte) |
| Santé / workflows cliniques | Dr. Workflow Wendy (Santé), Sprint Zero Sarah (PO), RGPD Raphaël (DPO) |
| RGPD / données personnelles / conformité | RGPD Raphaël (DPO), Paranoid Shug (Sécurité), Whiteboard Damien (Architecte) |
| BI / tableaux de bord / reporting / finance / comptabilité | Dashboard Estelle (BI Finance), Pixel-Perfect Hugo (Frontend), EXPLAIN PLAN Isabelle (DBA Oracle), Whiteboard Damien (Architecte) |
| Full-stack / sujet transverse | Whiteboard Damien (Architecte), SOLID Alex (Backend), Sprint Zero Sarah (PO), Edge-Case Nico (QA) |

Si le sujet couvre plusieurs domaines, choisir les 3-4 personas les plus pertinents. Toujours inclure **Whiteboard Damien (Architecte)** pour les décisions techniques. Toujours inclure **Sprint Zero Sarah (PO)** pour les décisions produit.

**Pool complet des personas avec rôles, perspectives et biais :** voir `reference/personas.md`.

**Announce the selected personas and their roles before starting the meeting.**

### Step 3: Run the Fast Meeting

The meeting uses sub-agents to run each persona independently and in parallel. The fast meeting compresses the process into 2 rounds.

**IMPORTANT: Use the Agent tool to launch each persona as a separate sub-agent.**

#### Round 1: Position and Recommendation (Parallel Sub-Agents)

Launch one sub-agent per persona **in parallel** using the Agent tool. Each sub-agent receives:

1. The **decision question** from Step 1
2. All **context** gathered (issue details, code snippets, constraints)
3. The persona's **identity prompt**

**Sub-agent prompt template:**

```
You are {name}, a {role}.

Your perspective: {perspective}
Your natural bias: {bias}

You are participating in a fast meeting about: {decision_question}

Context:
{context}

As {name}, provide your position:
1. What is your recommended approach? Be specific and concrete.
2. What are the top 2 risks? Be specific about failure scenarios.
3. What is your preferred implementation strategy in concrete steps?
4. What would you push back on from other typical perspectives?

Stay fully in character. Be concise and actionable — this is a fast meeting.

This is a research task — do NOT write or edit any files.
```

**Launch ALL persona sub-agents in a single message** so they run in parallel. Use `subagent_type: "general-purpose"` and a short description like `"Fast persona: {name}"`.

**Collect all positions** and present them as quotes:

> **SOLID Alex (Senior Backend Engineer):** "I recommend..."

#### Anti-Groupthink Check

After collecting Round 1 responses, evaluate the consensus level:

1. **Check if all personas converged on the same approach** (same recommendation, no meaningful disagreement)
2. **If consensus is too high** (all personas agree on the approach with no pushback):
   - Launch **one additional sub-agent** as a devil's advocate, prompted to find the strongest argument against the consensus position
   - Use this prompt:
     ```
     You are a devil's advocate in a fast meeting.

     All participants agreed on this approach: {consensus_summary}

     Your job: find the strongest possible argument AGAINST this consensus.
     - What could go wrong t