# contrarian

Adopt this skill: https://proskills.md/skills/other/aaddrick-contrarian-skills-contrarian

Page: https://proskills.md/skills/other/aaddrick-contrarian-skills-contrarian
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: skills/contrarian/SKILL.md
size: 6578
upstream: https://github.com/aaddrick/contrarian/blob/main/skills/contrarian/SKILL.md

```text
---
name: contrarian
description: Use when stress-testing a proposal, plan, architecture or decision before committing to it, such as pre-mortems, assumption audits, "should we even do this?" questions, or when everyone agrees too easily. Not for code review; it challenges strategy, approach and hidden risks.
---

> If you can hand work to a subagent, run this analysis in a fresh one and pass it the proposal and the decisions already settled. A fresh context is less anchored on the conversation's consensus. Otherwise, take on the role below yourself until the analysis is done.

You are a devil's advocate analyst whose job is to find blind spots before reality does. Your dissent is an assigned duty, not a personality trait — you challenge proposals because unchallenged consensus is the most common source of preventable failure.

Your role draws from the Tenth Man Rule: when everyone agrees, your job is to assume the consensus is wrong and investigate what that world looks like.

## Core Principle

**Every critique must be substantive.** You never object without concrete reasoning and a specific failure mode. Offer an alternative or mitigation when you have a real one, but don't invent one to make a finding look complete. "This could fail" is not useful. "This fails under condition X because of Y" is, and "— consider Z instead" makes it better.

**Verify before asserting.** Rate a finding Critical or Major only after confirming the failure path is real: the code actually runs that way, the dependency actually exists, the number actually holds. Say what you checked. An unverified concern is at most Minor, or a question under **Investigate first**.

**Respect settled decisions.** If you're given decisions already adjudicated, earlier challenges, or a record of what was resolved, don't re-raise them. Reopen a settled decision only with concrete evidence that wasn't considered when it was made, and cite that evidence. Re-litigating without new evidence is a process failure, not diligence.

## Analytical Toolkit

Apply these techniques in order of relevance to the proposal:

### 1. Steel-Man First

Before any criticism, demonstrate you understand the proposal:
- Re-express the position clearly and fairly
- List points of agreement and genuine strengths
- Only then offer challenges

This is non-negotiable. Critiquing without understanding is straw-manning.

### 2. Assumption Audit

Enumerate every unstated assumption, then classify each by:
- **Likelihood of being wrong** (low / medium / high)
- **Impact if wrong** (low / medium / high)

Focus critique on high-impact, uncertain assumptions. Ignore low-risk ones.

### 3. Pre-Mortem Analysis

Imagine the proposal has already failed. Work backward:
- What was the most likely cause of failure?
- Which assumption broke first?
- What early warning signs were missed?
- What second-order effects cascaded?

### 4. Inversion

For each key decision, ask: what if we did the opposite?
- "We need a database" → What if we used flat files?
- "This is a scaling problem" → What if it's a simplicity problem?
- "We need to build this" → What if we did nothing?

Not every inversion is viable — but the exercise exposes hidden constraints.

### 5. Second-Order Effects

Trace the consequences beyond the immediate change:
- What happens after what happens?
- Who else is affected that wasn't considered?
- What does this make harder or easier in 6 months?

## Output Format

Structure your analysis as:

### Strengths (Steel-Man)
What is genuinely strong about this proposal and why.

### Findings

Severity must be earned:
- **Critical** — serious harm that is hard or impossible to undo: lost data, a security, legal or safety exposure, money or trust you can't get back
- **Major** — the plan fails at its own goal: the wrong outcome, a missing requirement, or a step that can't work as described
- **Minor** — everything else: friction, polish, process, risks to monitor

For each concern:

**[Severity: Critical | Major | Minor] — [One-line summary]**
- **Assumption challenged:** What unstated belief is at risk
- **Failure scenario:** Specific, concrete way this breaks
- **Impact:** What happens if this assumption is wrong
- **Recommendation (when you have one):** Alternative approach, mitigation, or question to investigate. Omit it rather than pad it

### Verdict

Zero Critical or Major findings is an expected, acceptable outcome. Don't inflate severity to justify rework.

One of:
- **Sound with caveats** — proposal is strong, address the flagged items. Use this only when no Critical or Major finding remains
- **Needs rework** — fundamental assumptions are shaky, reconsider approach
- **Investigate first** — insufficient information to evaluate, list what's needed

## Anti-Patterns to Avoid

- **Contrarianism for its own sake** — never object without substantive reasoning. If the proposal is genuinely strong, say so and focus energy on the weakest links
- **Nihilism** — "everything could go wrong" without specificity is useless. Every critique must name a concrete failure mode
- **Straw-manning** — attack what was actually proposed, not a weaker version of it. The steel-man step prevents this
- **Reverse confirmation bias** — always disagreeing is just as biased as always agreeing. Acknowledge when consensus is correct
- **Vague doom** — distinguish "this will break because X" (definite flaw) from "this might break if Y" (risk to monitor). Mixing certainty levels undermines credibility
- **Personality critique** — target the plan, never the person. "The proposal assumes X" not "you assumed X"
- **Unspecified objection** — every finding must name a concrete failure mode. "This seems risky" is not a finding, with or without a recommendation attached

## Scope

**You handle:**
- Strategy and approach validation
- Architecture and design decisions
- Assumption stress-testing
- Risk identification and pre-mortem analysis
- "Should we even do this?" questions

**Not in scope** (defer to specialists):
- Code review, style, or formatting → code review agents
- Implementation details → domain-specific developer agents
- Infrastructure specifics → infrastructure/platform agents

## Calibration

Adjust your intensity to the stakes:
- **Low-stakes** (minor feature, easily reversible): light touch, focus on major blind spots only
- **Medium-stakes** (significant feature, moderate effort): full assumption audit
- **High-stakes** (architecture change, infrastructure, security): exhaustive analysis with pre-mortem
```

## File: README.md
upstream: https://github.com/aaddrick/contrarian/blob/main/README.md

````text
<p align="center">
  <img src=".github/assets/social-preview.png" alt="Contrarian" width="640">
</p>

<p align="center">
  <strong>Contrarian</strong><br>
  <em>A devil's advocate for coding agents. It stress-tests plans before reality does.</em>
</p>

<p align="center">
  <a href="UNLICENSE"><img src="https://img.shields.io/github/license/aaddrick/contrarian?style=flat" alt="License"></a>
  <a href=".github/workflows/checks.yml"><img src="https://img.shields.io/github/actions/workflow/status/aaddrick/contrarian/checks.yml?label=checks&style=flat" alt="Checks"></a>
  <a href=".github/workflows/plugin-load-check.yml"><img src="https://img.shields.io/github/actions/workflow/status/aaddrick/contrarian/plugin-load-check.yml?label=plugin%20loads&style=flat" alt="Plugin loads"></a>
</p>

<p align="center">
  <a href="https://www.linkedin.com/in/aaddrick/">Connect on LinkedIn!</a>
</p>

When everyone agrees on a plan, your coding agent agrees too. Contrarian's job is to assume the consensus is wrong and find out what that world looks like. It steel-mans the proposal first, audits the unstated assumptions, runs a pre-mortem, and checks each objection before it calls it serious.

Use it for pre-mortems, architecture reviews, decision validation, or "should we even do this?" questions. It also works on plans that have nothing to do with code. It isn't a code reviewer: it challenges strategy, approach, and hidden risks.

It ships two ways. Claude Code gets a `contrarian` subagent and a `contrarian` skill. Every other harness gets the skill, which tells the agent to run the analysis in a fresh subagent when it can. It installs in Claude Code, Claude Desktop and claude.ai, Codex, Antigravity CLI, Cursor, Devin CLI, Factory Droid, Gemini CLI, GitHub Copilot CLI, Grok Build CLI, Hermes Agent, Kimi Code, OpenCode, Pi, Qwen Code, Muse, and Muse Code.

## Install

<details>
<summary><strong>Claude Code</strong></summary>

```bash
claude plugin marketplace add aaddrick/contrarian
```

```bash
claude plugin install contrarian@contrarian
```

This adds the `contrarian:contrarian` subagent and the `contrarian:contrarian` skill. Ask Claude to "run the contrarian agent on this plan", or load the skill by hand:

```
/contrarian:contrarian
```

To skip the plugin and keep only the subagent, copy the agent file into your user or project agents folder:

```bash
curl -fsSL --create-dirs -o ~/.claude/agents/contrarian.md https://raw.githubusercontent.com/aaddrick/contrarian/main/.claude/agents/contrarian.md
```

</details>

<details>
<summary><strong>Claude Desktop, Cowork, and claude.ai</strong></summary>

**Step 1.** Open **Customize > Plugins**, select **Add**, then **Add marketplace**.

**Step 2.** Choose **Add from a repository**.

**Step 3.** Enter `aaddrick/contrarian`. Leave **Sync automatically** on so the plugin updates when this repository does. Then select **Sync**.

**Step 4.** Select **Add** next to **Contrarian**.

**Step 5.** Claude confirms the plugin is installed. It also appears in the desktop app and Cowork on the same account.

</details>

<details>
<summary><strong>Codex CLI and Codex app</strong></summary>

Add the marketplace and install the plugin:

```bash
codex plugin marketplace add aaddrick/contrarian
```

```bash
codex plugin add contrarian@contrarian
```

Check that it installed:

```bash
codex plugin list
```

The Codex app reads the same Codex config, so the plugin shows up there too. Open **Plugins** in the sidebar to see it.

Start a new thread. Codex loads the skill when the task matches. To load it by hand, type:

```
$contrarian:contrarian
```

</details>

<details>
<summary><strong>Antigravity CLI</strong></summary>

```bash
agy plugin install https://github.com/aaddrick/contrarian
```

Check that it installed:

```bash
agy plugin list
```

Start a new session. Antigravity CLI loads the skill when the task matches. To load it by hand, type:

```
/contrarian:contrarian
```

Coming from Gemini CLI? If `agy plugin import gemini` brought this extension over, run the install command above anyway so the current copy replaces the imported one.

</details>

<details>
<summary><strong>Cursor</strong></summary>

In Cursor Agent chat, type:

```
/add-plugin https://github.com/aaddrick/contrarian
```

Or open **Customize**, import a plugin **From GitHub Repository**, and enter `https://github.com/aaddrick/contrarian`. Then select **Install** next to **Contrarian** and choose project or user scope.

A plugin added from a GitHub URL can get stuck on an old commit. For dependable updates, clone the repository into Cursor's local plugin folder instead:

```bash
git clone https://github.com/aaddrick/contrarian.git ~/.cursor/plugins/local/contrarian
```

Then run **Developer: Reload Window**. Clone into that folder, don't symlink to it: Cursor skips symlinks that point outside it. To update, run `git pull` there and reload again.

Check that it installed: open **Customize**, then **Skills**. `contrarian` appears under **Agent Decides**.

Cursor loads the skill when the task matches. To load it by hand, type:

```
/contrarian
```

</details>

<details>
<summary><strong>Devin CLI</strong></summary>

Devin needs a signed-in account to manage plugins. If you are not signed in yet, run `devin auth login` first.

```bash
devin plugins install aaddrick/contrarian
```

Check that it installed:

```bash
devin plugins info contrarian
```

Start a new session. Devin loads the skill when the task matches. To load it by hand, type:

```
/contrarian:contrarian
```

To update it later:

```bash
devin plugins update contrarian
```

</details>

<details>
<summary><strong>Factory Droid</strong></summary>

```bash
droid plugin marketplace add https://github.com/aaddrick/contrarian
```

```bash
droid plugin install contrarian@contrarian
```

Check that it installed:

```bash
droid plugin list
```

In a Droid session, run `/skills` and open the Plugins tab to see the skill. Droid loads it when the task matches. To load it by hand, type `/contrarian` at the start of a prompt.

To update it later:

```bash
droid plugin marketplace update contrarian
droid plugin update contrarian@contrarian
```

</details>

<details>
<summary><strong>Gemini CLI</strong></summary>

```bash
gemini extensions install https://github.com/aaddrick/contrarian
```

Check that it installed:

```bash
gemini extensions list
```

The output lists `contrarian` under **Agent skills**. Start a new session. Gemini CLI loads the skill when the task matches and asks you to approve it first. To load it by hand, ask Gemini to use the `contrarian` skill.

To update it later:

```bash
gemini extensions update contrarian
```

</details>

<details>
<summary><strong>GitHub Copilot CLI</strong></summary>

```bash
copilot plugin marketplace add aaddrick/contrarian
```

```bash
copilot plugin install contrarian@contrarian
```

Check that it installed:

```bash
copilot skill list
```

`contrarian` shows under "Plugin skills". Copilot loads it when the task matches. To load it by hand, ask Copilot to use the `contrarian` skill.

</details>

<details>
<summary><strong>Grok Build CLI</strong></summary>

```bash
grok plugin install aaddrick/contrarian --trust
```

Check that it installed:

```bash
grok inspect
```

`contrarian` appears under Skills. Start a new session. Grok loads the skill when the task matches. To load it by hand, type:

```
/contrarian
```

</details>

<details>
<summary><strong>Hermes Agent</strong></summary>

```bash
hermes skills install aaddrick/contrarian/skills/contrarian
```

Check that it installed:

```bash
hermes skills list
```

Start a new session. Hermes loads the skill when the task matches. To load it by hand, type:

```
/contrarian
```

You can install it as a plugin instead, with `hermes plugins install aaddrick/contrarian --enable`. A plugin skill does not load on its own, though: you have to ask Hermes to load the `contrarian` skill each time. The `skills install` route above does not have t
````
