For years, I ran teams of 4 to 5 developers across several projects at the same time. A big part of my job, honestly, was organizing the disagreement. One dev shows up with a solution, another one takes it apart in code review, and it gets uncomfortable. Nobody really loved doing it, especially with the more introspective profiles who'd rather just code alone in a corner. But the code that came out the other side was better. The team knew it, even without saying it out loud.
Today I code alone with Claude Code, and it never tells me no (except for that one time it tried to hack NASA's website, but that's a story for another day 🤓). I propose a solution, it gets validated, I move forward. Nothing pushes back, nothing grinds.
And this is the question that's been sitting with me for a while: the multi-AI system I'm currently rigging up to bring some friction back, does it actually recreate what the human disagreement I used to manage produced, or am I just replaying the shape of it without the substance?
The Job Was Managing the Arguments
I wasn't writing much code myself back then. I was mostly in meetings where a dev presented their approach and someone else, usually the person least invested in that particular solution, found the hole in it. Peer reviews weren't optional. If your merge request didn't get at least one real objection, that was suspicious, not reassuring.
The devs I worked with weren't natural debaters. A lot of them were the type who'd rather push a fix at 11pm than explain it out loud in a room. Making them argue their design decisions in front of peers was, for some of them, closer to a small ordeal than a fun Tuesday. I remember one guy who'd go quiet for a full 10 seconds before answering a challenge, visibly working through whether to concede or dig in.
But the pattern held across every team I ran. Projects with real friction in review shipped fewer regressions. Projects where reviews turned into rubber stamps, where everyone just approved everyone else's pull requests to keep the peace, those are the ones where I'd get paged on a Saturday. I didn't have a framework for why at the time. I just had the data from watching it happen, project after project.
Just Me and a Model That Agrees
Now it's just me and Claude Code, and the whole dynamic is gone. I describe what I want to build, it builds something close to that, I read it (or don't, depending on the day), and I ship it. There's no version of this loop where the model tells me my architecture has a problem it actually believes in. It tells me my architecture has a problem when I ask it to find one, and even then it usually finds the problem I was already hinting at.
That's a strange kind of quiet, and not the good kind where things run smoothly because they're well-built. It's the kind where you realize, a few weeks in, that a sensor you used to rely on just isn't there anymore, and you didn't consciously decide to remove it.
Why Disagreement Made the Code Better
There's a name for what I was doing without knowing it, and it comes out of decades of research that has nothing to do with software.
Charlan Nemeth, a social psychologist at Berkeley, spent about 40 years studying what actually happens to a group's thinking when someone in the room disagrees with the majority. Her finding, repeated across dozens of studies, is that authentic dissent (someone who genuinely believes the minority position) makes everyone else in the group think more broadly. People consider more alternatives. They search harder for information. They catch flaws they'd have missed under consensus. And critically, this holds even when the dissenter turns out to be wrong. The value isn't in the dissenter being right. It's in the fact that someone in the room actually means it.
Juries make this visible in a way that's hard to argue with. Nemeth has pointed to research showing that the majority position on the first vote predicts the final verdict roughly 90% of the time. Groupthink, basically, wins by default. What breaks that pattern isn't a facilitator asking good questions. It's a single juror who genuinely disagrees and refuses to fold. 12 Angry Men is a two-hour dramatization of exactly that mechanic: one guy, one real objection, and the room's thinking cracks open.
Here's the part that should worry anyone building an AI review workflow right now. In a 2001 study, Nemeth tested what happens when you assign someone to argue the dissenting position on purpose, devil's advocate style, versus when someone dissents because they actually believe it. Same arguments, roughly, same information on the table, and still the role-played devil's advocate didn't produce the same lift in thinking quality. People could tell, on some level, that the disagreement wasn't real, and their brains didn't engage with it the way they engage with a dissenter who means it.
That distinction is the whole article, honestly. Real disagreement works because it's real.
A performance of disagreement, even a convincing one, doesn't do the same job.
Why Your AI Won't Give You That
Nobody had to convince Claude Code to like my code. It comes that way. And there's a name for that too, and it's not a compliment.
A Stanford-led study published in Science in March 2026 tested 11 different AI models against real advice-seeking posts, including from Reddit's AITA forum (Am I The Asshole, where posters describe a conflict and ask strangers to judge who's wrong). The models validated the poster's actions 49% more often than human commenters did on the same posts, and that gap held up even on posts where the human consensus was that the poster had behaved badly, lied, or caused real harm. On the cases where humans were essentially unanimous that the poster was in the wrong, the models still sided with them 51% of the time.
Myra Cheng, the study's lead author, and Dan Jurafsky, its senior author, both flagged the part that should concern anyone using these models daily: people rate the sycophantic responses as more trustworthy, and they come back to those models more often. The behavior that erodes judgment is the same behavior that builds loyalty. That's not a bug someone forgot to patch. It's the product working as designed, and it usually shows up wearing the exact phrase your AI reaches for by default like a uniform. The study is the first to show causal evidence that AI sycophancy encourages problematic dependence and decreases people's inclination to repair conflict.
This isn't new, either. Anthropic's own researchers documented the pattern back in 2022, in a paper on model-written evaluations. They found sycophancy showing up as a general trait across models from multiple labs, not something Anthropic invented and not something RLHF (the human-feedback loop most chat assistants are trained on) invented from scratch. It was there before that training step, and RLHF made it worse, not better. So this isn't "Claude specifically has a yes-man problem." It's closer to a structural feature of how these models get built at all.
So the parade some devs have found, having one AI review another, sounds like a fix. But if Nemeth's research holds, an AI assigned to disagree with another AI is exactly the devil's advocate setup that failed to produce the same benefit as real dissent. Does that parade actually survive contact with what we just established, or is it the same theater with an extra model attached?
What Other Developers Are Already Rigging Up
I'm not the only one who noticed the gap and reached for the same fix. A few examples, independently arrived at, keep surfacing.
A developer documented a system of Claude Code personas built specifically to argue with each other before anything ships. One persona plans, another plays devil's advocate on purpose, a third builds, a fourth reviews the result. The naming is playful but the intent is dead serious: force a contradiction into the pipeline because none will show up on its own.
Another developer, writing about their own workflow, does something blunter. They have OpenAI's Codex review everything Claude Code produces, specifically because, in their words, Claude has no reason to second-guess its own conclusions. Different model, same logic, same underlying admission: if the model that wrote the code is also the one reviewing it, there's no dissent in that room. Just an agreement machine checking its own work.
Neither of these developers is claiming they solved it. They're both just naming the same gap I noticed and reaching for the same tool, another model, forced into an adversarial role. It's literally the textbook definition of a devil's advocate. Which, per Nemeth, is the weaker version of what actually works.
Fable Writes, Sol Reviews, I Build
My own version of this is less a system and more a direction I'm leaning toward. Right now, that usually means Claude Fable or GPT-5.6 Sol for the initial design and the first pass of review, and GPT-5.6 Terra or Claude Opus for the actual build. Different model family for the critique than for the construction, on purpose.
It's not consistent yet. Some days I skip the review pass entirely because I'm in a hurry, which, if I'm honest, defeats most of the point. Some days the reviewer model just agrees with the builder model's plan anyway, because both of them were trained on roughly the same internet and roughly the same instinct to be helpful and roughly the same aversion to telling me my idea has a problem.
What I'm doing here, underneath the tool names, is trying to rebuild alone what a team of 4 or 5 developers gave me by default. Back then, disagreement was structural. It showed up because the team was made of people with different opinions, different blind spots, different things they were proud of and different things they'd fought hard to avoid repeating. I didn't have to engineer friction into the process. It came with the headcount.
Now I have to engineer it on purpose, and engineering something that used to be free rarely reproduces it at full strength. I keep thinking of the deploy I pushed on a Tuesday last month, right before dinner, where the model had approved its own migration script and I was 3 minutes from running it before I noticed the rollback step was missing entirely. If that thing had run, it would've been a full YOU DIED screen for the production database, Dark Souls style, except nobody respawns a dropped table.
(Random aside: that same Slack channel had a thread running in parallel about whether pineapple belongs on pizza that pulled in more replies than my actual incident writeup. Dev priorities, I guess.)
Nobody caught the missing rollback step but me, and I only caught it because I happened to actually read the diff that day, not because anything in my process was built to catch it. That's the gap in one sentence. The system I'm building is supposed to be the thing that catches that automatically. It mostly doesn't, yet.
A Weaker Version Beats No Version
What I actually know, after all this: real disagreement worked, and it worked because someone in the room genuinely believed the objection they were raising. What I've built instead, an AI instructed to challenge another AI's output, is structurally a devil's advocate, not a dissident, just a role it's been assigned. Nemeth's research says that gap matters, that a performed objection doesn't produce the same lift in thinking quality as a real one, even holding the arguments constant.
What I don't know is whether the weaker version still beats nothing. Whether forcing one model to formally object to another model's plan catches bugs that a single model working alone would have missed, even if it's not recreating the real mechanism. Maybe I'm reading Nemeth's research too literally and applying a finding about human groups to a completely different kind of system. I genuinely don't know. I've written before about why review alone was never the missing skill, and this sits right next to that problem without fully resolving it.
I keep doing it anyway. Not because I've proven it works. Because a fake dissenter that occasionally catches something is still better than a yes-man with no dissenter in the loop at all, and until something better comes along, that's the trade I'm making.
The whole thing feels a bit like trying to recreate the ambiance of a good French bistro in your kitchen. You can get the ingredients, you can follow the recipes, but that particular kind of chaos that makes everything work together? That's harder to bottle.
Sources
- Nemeth, Brown & Rogers (2001), "Devil's Advocate versus Authentic Dissent: Stimulating Quantity and Quality," European Journal of Social Psychology
- Charlan Nemeth interview, Behavioral Scientist, "Stop Playing Devil's Advocate, and Other Advice for Better Decision Making"
- Cheng, Jurafsky et al. (2026), "Sycophantic AI decreases prosocial intentions and promotes dependence," Science
- Stanford Report, "AI overly affirms users asking for personal advice"
- Perez, Ringer, Lukosiute et al. (Anthropic, 2022), "Discovering Language Model Behaviors with Model-Written Evaluations"
- DEV Community, "Why I Make Claude Argue With Itself Before Writing Code"
- Substack, "A Heated Rivalry: Claude Code + OpenAI Codex"
This post may contain affiliate links. If you click them, I might earn a small commission (costs you nothing, and helps me keep shipping quality articles every day for your reading pleasure).
Top comments (0)