⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

v1.1.0

contrarian

aaddrick@aaddrick⭐ 43 stars· last commit 1mo ago· 0 open issues

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.

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐⭐ 43 on GitHubGitHub ↗

Growing

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

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

claude plugin marketplace add aaddrick/contrarian
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:

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

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.

Add the marketplace and install the plugin:

codex plugin marketplace add aaddrick/contrarian
codex plugin add contrarian@contrarian

Check that it installed:

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
agy plugin install https://github.com/aaddrick/contrarian

Check that it installed:

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.

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:

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

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

devin plugins install aaddrick/contrarian

Check that it installed:

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:

devin plugins update contrarian
droid plugin marketplace add https://github.com/aaddrick/contrarian
droid plugin install contrarian@contrarian

Check that it installed:

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:

droid plugin marketplace update contrarian
droid plugin update contrarian@contrarian
gemini extensions install https://github.com/aaddrick/contrarian

Check that it installed:

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:

gemini extensions update contrarian
copilot plugin marketplace add aaddrick/contrarian
copilot plugin install contrarian@contrarian

Check that it installed:

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.

grok plugin install aaddrick/contrarian --trust

Check that it installed:

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
hermes skills install aaddrick/contrarian/skills/contrarian

Check that it installed:

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

// HOW IT'S BUILT

// FILES

2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • skills/contrarian/SKILL.md6.4 KBupstream ↗
    ---
    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
    
  • README.mdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/aaddrick-contrarian-skills-contrarian.md

// REPO STATS

43 stars
0 open issues
Last commit: 1mo ago