/opinion

description: Technical decision analysis from expert agents launched in parallel, with clear recommendation
argument-hint: "[topic or question] [--workflow] [--solo]"

Technical Decision Analysis

Analyze technical decisions by launching expert agents in parallel. Each agent provides their perspective, then results are aggregated into a clear recommendation.

**DO NOT ask the user which option to choose.** Analyze and recommend.

> **IMPORTANT:** If the spec below invokes any deferred tool (e.g. `AskUserQuestion`), you MUST load and call it as specified. Never skip the call, never substitute a default answer of your own — the tool invocation is part of the contract. This is critical.

Usage

/lets:opinion                 # Frame the decision interactively, then analyze
/lets:opinion <topic>         # Analyze the given decision
/lets:opinion ... --workflow  # Expert fan-out + adversarial challenge off-context via a Dynamic Workflow
/lets:opinion ... --solo      # In a team worktree: one-shot experts, not the team's members

Step 1: Frame the Problem

**Parse the argument:** strip a `--workflow` token if present (sets workflow mode) and a `--solo` token (team mode off - `protocol/agents.md` `## Team mode`; route gets `solo`); the rest is the topic. Mirror how `/lets:plan` strips `--fast`.

**Decision:** {what needs to be decided}
**Options:** A) ... B) ... C) ...
**Constraints:** {time, compatibility, legacy, budget}

Workflow execution flag

If `--workflow` is present, run the expert fan-out + challenge + synthesis inside a Dynamic Workflow instead of launching agents via the Task tool (Step 4 / 4.6 / 5 happen off-context; only the aggregate returns).

Choosing the execution path (interactive)

When `--workflow` was NOT explicitly passed:

• If the `Workflow` tool is **not** available this session -> silently use the standard Task-based path. Do NOT show the option.
• If the `Workflow` tool **is** available -> ask via `AskUserQuestion`:

AskUserQuestion(
  questions=[{
    question: "How should I run this analysis?",
    header: "Run mode",
    options: [
      { label: "Standard (Recommended)", description: "Experts via Task tool - full per-agent opinions visible inline" },
      { label: "Workflow", description: "Dynamic Workflow - off-context fan-out + challenge, only the recommendation returns" }
    ],
    multiSelect: false
  }]
)

**Handle response:** Standard -> standard path; Workflow -> treat as if `--workflow` was set (go to `## Workflow Mode` after expert selection); Other -> honor a named path else default to Standard. An explicit `--workflow` flag always wins over this prompt.

Step 2: Select Experts

Based on the decision topic, select relevant experts. Recommended defaults:

| Decision about... | Recommended experts | |-------------------|-------------------| | Auth/tokens/encryption | security, architect, backend, pragmatist | | DB schema/migrations | database, architect, backend, pragmatist | | Docker/CI/deploy | devops, security, architect, pragmatist | | API design | architect, backend, security, pragmatist | | UI/UX/components | frontend, architect, qa, pragmatist | | Testing strategy | qa, backend, architect, pragmatist | | Performance | backend, database, devops, pragmatist | | General architecture | architect, security, backend, pragmatist | | Code quality | architect, compliance, qa, pragmatist |

Adjust based on decision complexity - add more experts for cross-cutting decisions, fewer for simple binary choices.

**Guidelines:**

• `architect` and `pragmatist` always included
• Table above is a starting point, not a cap - add or remove agents based on context
• `actor` is **never auto-selected** - offer it only on an explicit user request that includes a personality source (URL or file). When the user requests it, invoke `Skill(skill: "lets:actor-fetch-personality", args: "<personality-source-from-user>")` to fetch the personality. Pass the returned `PERSONALITY:` block in the actor's Task prompt only.
• Agents inherit the session model (no per-agent model pins)

**Confirmation gate:** If planning to launch more than 10 experts: `{LETS_GATES}` is `strict` -> the question below; otherwise (missing reads as `standard`) -> print `Launching {N} experts` and launch all.

AskUserQuestion(
  questions=[{
    question: "Planning {N} experts for this decision. That's a lot - confirm?",
    header: "Confirm",
    options: [
      { label: "Launch all", description: "{N} experts, thorough analysis" },
      { label: "Reduce", description: "Suggest fewer, more focused experts" }
    ],
    multiSelect: false
  }]
)

Step 3: Gather Context

LETS_PROJECT_ROOT=$(git rev-parse --show-toplevel)
cat "$LETS_PROJECT_ROOT/CLAUDE.md" 2>/dev/null | head -100

Step 3.5: Show Expert Panel

Before launching, display the selection:

## Expert Panel

Decision: {topic summary}
Selected {N} experts:
1. architect - {reason from topic match}
2. pragmatist - always included
3. {domain agent} - {reason}
...

> Subagents have a separate rate limit - no cost to your conversation.

Analyzing...

Step 4: Launch Agents in Parallel

Read `${CLAUDE_PLUGIN_ROOT}/protocol/agents.md` before this step unless its text is in your current context.

**If `--workflow` was parsed:** skip this step (and Step 4.6 / the in-context aggregation) - go to `## Workflow Mode` below, then resume at Step 5 with the returned aggregate.

**Team mode** (`protocol/agents.md` `## Team mode`): `Skill(skill: "lets:member-run", args: "op=route command=opinion roles=<the panel, bare> fallback=one-shot")` first (`--solo` adds `solo`). A member line gets one item per panel role it takes - the opinion prompt below; the Task calls are the fallback's.

Open the run: `Skill(skill: "lets:agent-report", args: "op=open command=opinion task={task-id} names={comma-separated agent short names}")` (task omitted when none). Each prompt carries its agent's `R