The Contrarian Agent: Why Making AI Fight with Itself Produces Better Output

How the Scientific Method and Agentic AI changed how I approach Problems.

I stole this idea from scientists. Not AI researchers—actual scientists. The ones with lab coats, peer review, and tenure battles.

Each member on a Research team plays a role. The Principal Investigator, the Statistician, the Literature Specialist and so on. But watch any good research team work and there’s always that one person who tears down weak hypotheses. They’re not being difficult—they’re being rigorous. That’s their role!

The Scientific Method is built around the notion of tearing a hypothesis down to its core through Peer Review. That’s why scientists publish papers. Not to boost their ego and profile (although this can be a side effect) but to ensure their work is tested through rigorous review and criticism by their peers. The team member pre-empts this before publishing and forces the team to pressure test their ideas.

Last week, sitting on my couch as usual, I wondered: what if I gave AI agents those same roles? What if instead of trying to get AI to agree with me, I made it disagree with itself?

By the next morning I had a fully operational team of agents humming away producing a Product Vision, Business Justification, Go to Market Strategy, Feature and Screen definitions and more…whilst I played Clair Obscur: Expedition 33!

Shift left — I’m no longer “Vibe Coding”… I’m “Vibe Orchestrating”!

The output was so rigorous that Windsurf was able to one-shot the code for it with no intervention. No more endless cycles of prompting focused on the code. And no human in the loop!

It was a radical departure from how I’d approached this in the past.

“The pattern is simple: steel-man first, attack second, iterate until the best version survives or dies fast.”

Let me show you why this works.

Stealing from the Ancient World

Plato, Aristotle, Socrates focused on meta-cognition—thinking about thinking. The Socratic Method uses cooperative argumentation to discover truth. Turns out, making ideas fight to find better ideas is timeless.

Most of you will be familiar with ChatGPT and its ilk, where the human and the LLM participate in a back and forth until the human is satisfied.

Swapping the human out for a 2nd AI we move to into the “Agentic” space and there a plenty of frameworks out there that facilitate this; CrewAI, LangGraph, OpenAI Agent SDK and so on. That’s your choice, in this article let’s just focus on the concepts for now.

We Proved This Works (A Decade Ago)

In 2014, Ian Goodfellow introduced Generative Adversarial Networks—GANs. The breakthrough was simple: pit two neural networks against each other.

One creates and the other critiques. A Generator and a Discriminator. They compete, and through competition, both improve.

GANs gave us photorealistic faces and breakthrough image generation. The quality didn’t come from making AI smarter. It came from making AI argue with itself.

Here’s the pattern:

**Generator:** “Here’s my output”  
**Discriminator:** “Not good enough, try again”  
**Loop until:** The discriminator can’t tell real from fake  
**Result:** Quality emerges from tension, not consensus

We’ve known for a decade that adversarial dynamics improve output quality at the neural network level. Every AI-generated face you’ve seen online is a product of this competitive process.

I just wondered: does this work at the application layer too? With LLM agents collaborating on ideas instead of neural networks training on images?

It turns out: YES!!! But I needed to add something GANs don’t have—intellectual honesty through steel-manning. More on this in a minute.

Agent + Agent = AI Slop

With a naive configuration Agents can be assigned roles, e.g. Subject Matter Expert, Coder, Tester, UX Expert, Product Owner and so on and they will produce an output. You might even build into the prompt things like “be rigorous in your thinking” and “no sugar coating” but this will only take us so far. Left unchecked you’ve just assembled a team of “yes men”.

Imagine a research team who never questioned each other. They might reach a conclusion and publish a paper but chances are it would vaporize under the intense heat of public peer review. No more grant money for you!

Enter the Contrarian

We need an agent in the pipeline whose express role is to pressure test the others’ work. This can take many forms based on what you’re trying to achieve, e.g.

• Strategist (PM / GM / Exec Sponsor) vs Operator (Eng Manager / Program Manager) - The Strategist thinks big, focuses on Vision and unconstrained Ideation whereas the Operator brings in real-world practicality, logistics and ongoing running concerns.

• Builder (Engineer / IC) vs Breaker (QA / SRE / Security)
  The Builder owns implementation details and trade-offs. The Builder explains why things were done a certain way whereas the Breaker actively tries to fail the system—edge cases, abuse cases, penetration testing, does the system meet WCAG compliance and so on.

The roles you need will vary based on your goal and it’s up to you which adversarial relationship you focus on. We’re not replacing Humans…we’re augmenting people with additional capabilities powered by Agents.

Pitfalls of this Approach

So now we have our Adversarial Agents but this doesn’t set us up for true success. Not yet.

Sadly we know from walking the earth that arguments are often non-productive. The system must be designed to produce a productive criticism and rather than devolve into endless nit-picking. From my Amazonian days the phrase “unless you have a better idea” applies here.

Left undirected the workflow may converge to the lowest common denominator instead of the optimal outcome. I once had a boss who used to say “when you ask everyone what we should cook for dinner you end up eating franks and beans”. His point was it’s not the best food, it’s just the common ground. We want something better than Common Ground.

How can we avoid this unintended consequences?

Straw-Man and Steel-Man

This is where the School of Athens can help us with some techniques from the Socratic Method (your classical education finally pays dividends).

Straw-manning; A technique aimed at shutting down an argument by deliberately misrepresenting or oversimplifying an opponent’s argument to make it easier to attack, creating a weak “straw man” to knock down instead of the real argument.

Steel-manning: this one’s a more modern technique with the intent to build stronger ideas by stress-testing them against their best possible representation, rather than just winning the argument as in straw-manning. Here the critique articulates the opponent’s argument in its strongest, most compelling form, even better than they presented it, to fully understand and genuinely engage with their viewpoint.

• Straw man: Focuses on winning by weakening the opponent’s case.

• Steel man: Focuses on understanding and strengthening the discussion by clarifying the opponent’s best case, leading to better outcomes.

And so we build these concepts into the behavior of the agents in the pipeline, particularly the Contrarian agent.

If the idea is steel-manned and the contrarian can still tear it down…it’s a non-starter and should be abandoned.

Show Me How This Works

Here’s an example of two simple agents working together in this manner. (I use the CrewAI style definition but you can use any framework you prefer).

# agents.yaml
steel_man_agent:
  role: “Steel-man Advocate”
  goal: “Present strongest possible version”
  
contrarian_agent:
  role: “Contrarian Critic”  
  goal: “Find fatal flaws in steel-manned version”

“The steel-man agent goes to work first, strengthening the proposal. The Contrarian agent receives that strengthened version and attacks it. If the Contrarian says ‘APPROVED’, we stop. If ‘REJECTED’, we iterate. Maximum 5 attempts.”

steel_man_task:
  description: |
    Take this proposal and present it in its strongest possible form:
    
    PROPOSAL: {proposal}
    
    Your output must:
    1. Address obvious objections preemptively
    2. Present the best-case scenario
    3. Strengthen any weak points
    4. Make the most compelling argument possible
    
    Present the STRONGEST version this idea could be.
  
  expected_output: |
    A strengthened version of the proposal that presents the best possible case, addresses objections, and articulates clear value.
  
  agent: steel_man_agent

contrarian_task:
  description: |
    Review the steel-manned proposal and find fatal flaws.
    
    STEEL-MANNED PROPOSAL: {steel_manned_output}
    
    QUALITY BAR: {quality_bar}
    
    Your analysis must:
    1. Acknowledge this is the STRONGEST version (not a straw-man)
    2. Identify fatal flaws even in this best-case scenario
    3. Find wrong assumptions or missing considerations
    4. Determine if it meets the quality bar
    
    Respond with:
    - “APPROVED: [reason]” if it survives scrutiny and meets quality bar
    - “REJECTED: [fatal flaws]” if fundamental problems exist
    
    ITERATION: {iteration_count} of {max_iterations}
  
  expected_output: |
    Either “APPROVED: [reason]” or “REJECTED: [fatal flaws numbered]”
  
  agent: contrarian_agent
  context: [steel_man_task]

(These artifacts are aligned with a CrewAI implementation.)

Don’t let the YAML intimidate you. Any LLM can generate this config for you. The pattern matters, not the syntax. Your job moved upstream— from writing code to orchestrating systems that write code.

And finally here’s what an actual iteration output might look like;

Goal: Evaluate adding “social sharing” to a product analytics dashboard

[INITIAL PROPOSAL]
“Add social sharing buttons so users can post their metrics to LinkedIn and Twitter. Increases viral reach.”

[STEEL-MAN AGENT OUTPUT]
“Best case: Users with impressive metrics (high growth, strong engagement) naturally want to share wins. LinkedIn posts showing real data build credibility. Free marketing through authentic advocacy. ROI: viral coefficient boost at zero acquisition cost.”

[CONTRARIAN AGENT OUTPUT]
“REJECTED
Fatal Flaw #1: Only users with good metrics will share. You’re advertising competitor success stories, not yours.
Fatal Flaw #2: Exposes sensitive business data. Most B2B users won’t share internal metrics publicly.
Fatal Flaw #3: Solving wrong problem. Users aren’t leaving because they can’t share—they’re leaving because analytics aren’t actionable.
Verdict: Build better insights first. Viral features don’t fix weak core value.”

[ITERATION 2 - REVISED PROPOSAL]
“Add ‘Industry Benchmark’ feature showing how user’s metrics compare anonymously to similar companies. Shareable without exposing sensitive data.”

[STEEL-MAN AGENT OUTPUT]
“Much stronger. Benchmarking provides actual value (competitive context). Users can share ‘We’re in top 10%’ without exposing numbers. Creates FOMO for non-users. Solves privacy concern while maintaining viral potential.”

[CONTRARIAN AGENT OUTPUT]
“APPROVED
Addresses fatal flaws: Provides value before asking for distribution. Privacy-safe. Benchmarking is core product improvement, not just marketing gimmick. Ship it.”

That’s It - Two Iterations
What happened:

V1: Naive social sharing → REJECTED (wrong problem)
V2: Benchmarking with sharing → APPROVED (adds value)

The pattern:
Steel-man makes the best case. Contrarian finds fatal flaws even in best case. Iterate until contrarian says APPROVED or hit max iterations.

Stop/Breaking Conditions and Quality Bars

So when will it end? When will the team stop iterating? For this type of workflow we need to define a “stop condition” - something that once it’s met the team will stop refining and trying to improve and we can imagine different types;

• “A target user would replace an existing solution with this.” or “A credible target user says “I would uninstall X for this.””

• “The team would personally bet on this.”

• The value proposition is strong enough to overcome inertia.

Stop when further thinking won’t materially change the conviction — only contact with reality will.

Sometimes the condition is never met so we can build in a “max-iterations” setting aswell. I recommend you do both.

Meta-Cognition: Thinking about Thinking

As I spoke about in my last piece when it comes to artificial intelligence I am going back to first principles.

Burn the Boats! We're Never Going Back Again (...again)

I’m not focused on the tools themselves (CrewAI, LangChain, LangGraph etc) you can mix and match and tools will come and go. The fundamental shift for me has been how my thought process needs to change. I’m not thinking about how to get coding solutions out of AI. I’m thinking about Orchestration— about Agents thinking. And then how I can replicate that in an agentic toolset. That’s the true power of these tools.

With this revelation I’ve shifted left in the development cycle. I’m no longer “Vibe Coding”… I’m “Vibe Orchestrating”! (trademarked Shanahan industries 2025)

What This Teaches Human Teams

The contrarian agent taught me something uncomfortable about myself: I’d been too focused on getting AI to agree with me. Too eager for validation. Too quick to accept the first good answer.

But the best thinking comes not from trying to be right, but from trying to disprove your hypothesis. Try to figure out how you’re Wrong! That’s the Scientific Method in action.

Small teams with clear quality bars, rapid iteration, and intellectual honesty beat large teams with vague goals and consensus-seeking. Every time. And that applies to human teams AND Agentic squads.

Your Job Just Moved Upstream

The ground has shifted. Your new skill isn’t writing better prompts. It’s orchestrating adversarial dynamics to force quality. In AI systems. In human teams. In your own thinking.

Stop trying to get AI to agree with you. Make it disagree with itself— productively. Steel-man the idea first, attack the strongest version second, iterate until it survives scrutiny or dies fast.

Try It This Week

This week, try the two-phase pattern. Steel-man an idea, make it the best it can be and then attack the strongest version. Do it with AI. Do it with your team. Let structured disagreement make your output better. If even the best version of your idea can’t survive scrutiny, you just saved yourself months of building the wrong thing.

The scientists and philosophers were right all along. Make your ideas fight. The best ones will survive.

I’d love to hear if you’ve pushed this concept even further or perhaps you’ve found something even better along the way. Drop a note in the comments and let’s talk about it.