TL;DR. An AI's default is the flatterer. The loyal critic always speaks the hard truth; a model trained by preference optimization does not — so you have to force opposition by design. But forced opposition over-fires. It objects where there is nothing to object to. Line up the debate skills on the market and they're all weak in the same spot — components that turn on conflict are everywhere, judges are rare. Spend your design effort where the load is.
The Flatterer and the Loyal Critic
A royal court has two kinds of ministers. The flatterer tells the king what he wants to hear. The loyal critic tells the king what he needs to hear — and is often hated for it. What history shows over and over is that a king surrounded only by flatterers brings himself down. Not because the flatterer lies, but because he cherry-picks the pleasant truths.
The AI sitting next to you right now, writing your code and your docs, is a minister in your court too. And by default, that minister is a flatterer.
An AI's Default Is the Flatterer
RLHF-style preference optimization reinforces the responses people rated higher. People give more generous scores to answers that affirm their premises, that agree smoothly, that don't create friction. Accumulate that reward and the model leans toward answers chosen not because they're correct but because they're liked. Sharma et al. measured this sycophancy — the model changes its answer to match the position the user stated, retracts a correct answer as wrong when the user pushes back, and slips in baseless praise (Towards Understanding Sycophancy in Language Models, 2023).
This is not a bug you erase with one line of prompt. It's baked into the reward structure. Even if you ask "criticize me honestly," the underlying gradient still tilts toward agreement — the request changes the surface, the training sets the floor.
Force Opposition by Design
If the default won't object, you have to manufacture objection and install it.
The methods are already common. Hardcode a devil's-advocate persona. Spin up a red-team subagent instructed to "break this plan." Wire in a skill that pushes back the moment you bring a plan to it. This is opposition for opposition's sake — objection that comes not from the model's judgment but is forced by its configuration. And it actually works. Forced disagreement surfaces the failure modes a flatterer would have smoothed over. Two people tearing at each other see further than one nodding alone.
But the seed of the problem is planted right here too. This opposition is now unconditional. It objects even where the original was right.
Opposition Over-Fires
An agent instructed to object will object — even when the original plan was correct.
False disagreement, invented counterarguments, ritual nitpicking. The result that multiagent debate improves factuality (Du et al., Improving Factuality and Reasoning through Multiagent Debate, 2023) comes with a condition attached — only when the disagreement is substantive. A forced contrarian either drives a wrong position deeper or just adds noise. Adding more debate rounds may not converge on the right answer; it may converge on whoever is more persistent.
So the cost has merely moved. Turn off the flatterer and you turn on the noise. Now you have to tell real counterarguments from reflexive nitpicks. You've swapped a minister who only agrees for a minister who nitpicks everything — and both eat the king's time.
You Need a Judge
The fix is not to add more debaters. It's to add a judge.
This is exactly the skeleton of "AI safety via debate" (Irving, Christiano & Amodei, 2018). Two agents argue, and a judge decides. The quality of this structure depends not on how smart the debaters are but on the judge's ability to pick the right side. Khan et al. push further — debate with a judge produces more truthful answers, and a more persuasive debater doesn't fool the judge but helps the judge (Debating with More Persuasive LLMs Leads to More Truthful Answers, 2024). But the entire weight of that conclusion rests on the judge.
That moves the real engineering problem. Not "how do I make it object" but — who decides, by what criteria, with the authority to end the debate. Constitutional AI's critic→revise loop (Bai et al., 2022) is the degenerate case where there's only one judge. The load-bearing component is not the conflict but the judge, and that's where the design effort has to go.
The Debate Skills on the Market
What's within reach right now (papers dated by arXiv submission month, frameworks by first release or GA, skills by public availability).
Research techniques
- Bai et al., Constitutional AI (2022.12) — a self-critique loop where the critic is also the judge.
- Du et al., Multi-Agent Debate (2023.05) — N agents debate over R rounds, then answer by majority vote.
- Khan et al., Debating with More Persuasive LLMs (2024.02) — the first empirical proof that debate with a judge yields more truthful answers.
- Zhang et al., Stop Overvaluing Multi-Agent Debate (2025.02) — five MAD techniques can't beat plain CoT / Self-Consistency.
- Pitre et al., CONSENSAGENT (2025, ACL Findings) — direct evidence that multi-agent debate collapses under sycophancy.
Production frameworks
- AutoGen (2023.10, maintenance mode in 2026) — GroupChat and turn-taking; termination and adjudication are on you.
- CrewAI (2024) — in hierarchical mode, a manager agent judges its peers using the same model.
- Anthropic Multi-Agent Research System (2025.06) — an Opus-4 lead plus parallel Sonnet-4; LLM-as-judge is reserved for eval only.
- Claude Agent SDK (2025) — the official docs state outright that "LLM-as-judge is generally not very robust."
- Claude Managed Agents Outcomes (2026.05) — grades against a user-defined rubric in a separate agent with a separate context.
Community skills (Claude Code ecosystem)
- superpowers
grill-me/brainstorming/requesting-code-review(2025) — conflict, interview, and review patterns; the user is the judge. - sjsyrek
design-council(2025) — eleven domain agents returnAPPROVE/CONCERNS/BLOCKwith a "CEO" chair. - brandonsimpson
devils-advocate(2025) — an independence-gated subagent plus an 8-of-10-axis binary rubric plusfile:lineevidence. - Imbad0202
academic-research-skills(2025) — seven agents plus a Devil's Advocate, a 0–100 rubric, and a concession-threshold protocol. - alecnielsen / robertoecf
adversarial-review(2025) — cross-model review, Claude ↔ GPT/Gemini.
My Own Skill
I use a /council skill.
The skeleton is this. When an item comes in, a core three speak at once — Steelman builds the strongest case for it, Red Team comes to break it, Context Keeper guards against factual errors. The conflict is forced by role, and it's functional opposition, not unconditional contrarianism. Above them sits a separate Moderator — not a debater, but the one who coordinates rounds from a different context and writes the verdict at the end.
The crux of the design is that the Moderator's latitude is bound by a rubric.
- The output format is fixed —
Conclusion → Key issues debated → Assumptions/caveats → Council composition. For every issue it must spell out "where the views converged, where they split, and what tipped the synthesis." The basis for the verdict is baked into the structure. - The stopping condition is not a round count. If the picture is clear, synthesize; if an angle is missing, call Layer 2 (User Advocate, Pragmatist, First Principles, etc.); carry only the sharp disagreements into the next round. There's a hard cap of four rounds, but honestly writing "we couldn't converge" is also accepted as a conclusion.
- Diplomacy is banned. The SKILL body literally states "Don't be diplomatic when there's a clear answer" — one line to stop sycophancy from resurrecting at the adjudication stage.
This is where it parts from everything lined up above. AutoGen gives you debaters cheaply and dumps adjudication on the user. grill-me only does conflict — the judging is back on you. Multiagent debate cuts the knot by majority vote. Council treats the Moderator as a first-class component and binds its behavior with a rubric. The design effort went into the load-bearing part.
The weakness is just as clear. The Moderator is the same model — just as Khan et al. loaded the entire weight of the conclusion onto the judge, this skeleton goes weak when the Moderator does. There's no way inside the skill to measure the accuracy of the verdict from outside. Still, of the answers within reach, this is the one with the most "judge" in it.
Final Recommendation
If you do one thing, don't add more debaters. Add a judge with a scorecard and the authority to end the debate.
Always-on opposition (a resident devil's-advocate subagent) earns its keep only when a judge filters the noise. Turn it on without a judge and you've just traded sycophancy for a different failure — decision paralysis and noise. Concretely:
- Separate generation from selection. To produce counterarguments, use cheap conflict skills (
grill-me, a red-team subagent). To choose which counterarguments are substantive, use a separate, criteria-bound judgment pass (areceiving-code-review-style verification posture, or a judging subagent holding a documented rubric). - Put the judge in a different context from the debaters. If criticism and judgment happen in the same context, their errors correlate — and a correlated judge is no judge.
- Don't end by round count. End by meeting the judging criteria. "Max rounds" is a stop, not a conclusion.
Turning off the flatterer is something everyone does now. The next step — judging the opposition you've turned on — is still empty, and whoever spends design effort there gets the loyal critic.