/opinion

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

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

Step 1: Frame the Problem

**Parse the argument:** strip a `--workflow` token if present (sets workflow mode); 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:

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

**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.

**CRITICAL:** Launch ALL selected agents in a SINGLE message with multiple Task tool calls.

For each selected agent:

Task(
  subagent_type="lets:{agent-name}",
  prompt="ultrathink

PROJECT_ROOT: {LETS_PROJECT_ROOT from LETS Config}. Do NOT read or search files outside this directory.

MODE: opinion

PROJECT CONTEXT:
{CLAUDE.md summary}

DECISION: {what needs to be decided}
OPTIONS:
A) {option A description}
B) {option B description}
C) {option C description - if applicable}
CONSTRAINTS: {context, time, legacy, etc.}"
)

Step 4.6: Challenge the Leading Option (Adversarial)

After the panel returns, identify the leading option - **the one the most experts recommend** (break ties by average score). Recommendation count is the single consensus axis (average score is only a tiebreak), so the option that gets challenged and recommended is always one the panel actually picked. Before finalizing, stress-test it. This is core methodolo