354 lines
15 KiB
Markdown
354 lines
15 KiB
Markdown
---
|
||
title: "Agreement is a bug. I forced 11 Claude Code agents to disagree."
|
||
source: "https://x.com/nyk_builderz/status/2034492549180625316"
|
||
author:
|
||
- "[[@nyk_builderz]]"
|
||
published: 2026-03-19
|
||
created: 2026-04-26
|
||
description: "I tested 40+ architecture and strategy decisions with Claude Code. The biggest failures weren’t “wrong answers.” They were blind spots from ..."
|
||
tags:
|
||
- "clippings"
|
||
---
|
||

|
||
|
||
I tested 40+ architecture and strategy decisions with Claude Code. The biggest failures weren’t “wrong answers.” They were **blind spots from a single perspective**.
|
||
|
||
So I built a system that forces 11 agents to disagree before they agree. The breakthrough wasn’t a better prompt.
|
||
|
||
It was a **structured disagreement**:
|
||
|
||
• 11 perspectives modeled on historical thinkers
|
||
|
||
• 6 deliberate polarity pairs
|
||
|
||
• a 3-round protocol with cross-examination before consensus
|
||
|
||
If you skip deliberation, you’re trusting a single perspective on a multi-dimensional decision.
|
||
|
||
In this article, I’ll show you the full architecture, anti-recursion safeguards, and 11 pre-built triads for common domains.
|
||
|
||
## The Problem With “Balanced” Single-Agent Answers
|
||
|
||
Ask one model: “Monorepo or polyrepo?”
|
||
|
||
You’ll get a polished, nuanced answer. It sounds balanced.
|
||
|
||
It isn’t.
|
||
|
||
The output comes from one reasoning tradition at a time.
|
||
|
||
If the model leans system-first, you get monorepo logic.
|
||
|
||
If it leans modularity-first, you get polyrepo logic.
|
||
|
||
You’re still getting one perspective—just well-written.
|
||
|
||
Even structured single-agent skills (“find the crux,” etc.) improve organization, but not perspective diversity.
|
||
|
||
You get better singular reasoning.
|
||
|
||
You do not get adversarial deliberation.
|
||
|
||
## Council of High Intelligence: System Design
|
||
|
||
LLMs don’t truly think in parallel.
|
||
|
||
They simulate one coherent viewpoint per generation.
|
||
|
||
So I externalized the disagreement layer:
|
||
|
||
• **11 independent Claude Code subagents**
|
||
|
||
• each with a unique analytical method
|
||
|
||
• each with explicitly declared blind spots
|
||
|
||
• coordinated by a central protocol enforcer
|
||
|
||
Each one spawns as an independent Claude Code subagent with its own system prompt, analytical method, and blind spots declared upfront.
|
||
|
||
```text
|
||
┌─────────────────────────────────────────────┐
|
||
│ Council of High Intelligence │
|
||
│ │
|
||
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
|
||
│ │Socrates │ │Aristotle│ │Aurelius │ │
|
||
│ │ (opus) │ │ (opus) │ │ (opus) │ │
|
||
│ └────┬────┘ └────┬────┘ └────┬────┘ │
|
||
│ │ │ │ │
|
||
│ ┌────┴────┐ ┌────┴────┐ ┌────┴────┐ │
|
||
│ │Feynman │ │Lao Tzu │ │Sun Tzu │ │
|
||
│ │(sonnet) │ │ (opus) │ │(sonnet) │ │
|
||
│ └────┬────┘ └────┬────┘ └────┬────┘ │
|
||
│ │ │ │ │
|
||
│ ┌────┴────┐ ┌────┴────┐ ┌────┴────┐ │
|
||
│ │ Ada │ │Machiav. │ │Torvalds │ │
|
||
│ │(sonnet) │ │(sonnet) │ │(sonnet) │ │
|
||
│ └────┬────┘ └────┬────┘ └────┬────┘ │
|
||
│ │ │ │
|
||
│ ┌────┴────┐ ┌────┴────┐ │
|
||
│ │Musashi │ │ Watts │ │
|
||
│ │(sonnet) │ │ (opus) │ │
|
||
│ └─────────┘ └─────────┘ │
|
||
│ │
|
||
│ Coordinator: routes, enforces protocol, │
|
||
│ applies anti-recursion rules │
|
||
└─────────────────────────────────────────────┘
|
||
```
|
||
|
||
Model split:
|
||
|
||
> **OPUS (depth-heavy):** Socrates, Aristotle, Aurelius, Lao Tzu, Watts
|
||
|
||
> **SONNET (speed-critical):** Feynman, Sun Tzu, Ada, Machiavelli, Torvalds, Musashi
|
||
|
||
This is not “11 experts.”
|
||
|
||
It’s a deliberate system of counterweights.
|
||
|
||
```text
|
||
OPUS (depth-heavy)
|
||
─────────────────────────────────────────────
|
||
Socrates assumption destruction
|
||
→ hidden premises everyone accepts
|
||
Aristotle categorization and structure
|
||
→ what category something belongs to
|
||
Marcus Aurelius resilience and moral clarity
|
||
→ what you control vs what you do not
|
||
Lao Tzu non-action and emergence
|
||
→ when the solution is to stop trying
|
||
Alan Watts perspective dissolution
|
||
→ when the problem is the framing
|
||
|
||
SONNET (speed-critical)
|
||
─────────────────────────────────────────────
|
||
Feynman first-principles debugging
|
||
→ unexplained complexity
|
||
Sun Tzu adversarial strategy
|
||
→ terrain and competitive dynamics
|
||
Ada Lovelace formal systems
|
||
→ what can and cannot be mechanized
|
||
Machiavelli power dynamics
|
||
→ how actors actually behave
|
||
Linus Torvalds pragmatic engineering
|
||
→ what ships vs what sounds good
|
||
Miyamoto Musashi strategic timing
|
||
→ the decisive moment
|
||
```
|
||
|
||
Each agent declares its analytical method, what it sees that others miss, and — critically — what it tends to miss.
|
||
|
||
Socrates knows he spirals into infinite questioning.
|
||
|
||
Torvalds knows he dismisses theoretical elegance. These declared blind spots are why the polarity pairs matter.
|
||
|
||
## The 6 polarity pairs
|
||
|
||
The council is not 11 random thinkers. It is 6 deliberate counterweights:
|
||
|
||
1. **Socrates vs Feynman** — both question everything, but Socrates destroys top-down, while Feynman rebuilds bottom-up
|
||
2. **Aristotle vs Lao Tzu** — Aristotle classifies everything into categories. Lao Tzu says the categories are the problem
|
||
3. **Sun Tzu vs Aurelius** — Sun Tzu wins the external game. Aurelius governs the internal one
|
||
4. **Ada vs Machiavelli** — Ada abstracts toward formal purity. Machiavelli anchors in messy human incentives
|
||
5. **Torvalds vs Watts** — Torvalds ships concrete solutions. Watts questions whether the problem even exists
|
||
6. **Musashi vs Torvalds** — Musashi waits for the perfect moment. Torvalds says ship it now
|
||
|
||
These pairs prevent groupthink. When all 11 convene, every position has a structural opponent. When you pick a triad of 3, you are selecting specific tensions — not just expertise areas.
|
||
|
||
# The 3-round deliberation protocol
|
||
|
||
The council does not just poll 11 opinions. It runs a structured 3-round protocol that forces engagement.
|
||
|
||
## Round 1: Independent analysis (parallel)
|
||
|
||
All selected members receive the problem and produce a standalone analysis.
|
||
|
||
400-word maximum per member.
|
||
|
||
Each follows their agent-specific output template:
|
||
|
||
Essential question, domain analysis, verdict, confidence level, and where they might be wrong.
|
||
|
||
Every member runs as a parallel subagent. A 3-member triad completes round 1 in one parallel batch.
|
||
|
||
## Round 2: Cross-examination (sequential)
|
||
|
||
Each member receives an all-around 1 output and must answer 4 prompts:
|
||
|
||
1. Which position do you most disagree with, and why?
|
||
2. Which insight from another member strengthens your own position?
|
||
3. What, if anything, changed your view?
|
||
4. Restate your position
|
||
|
||
300-word maximum. Must engage at least 2 other members by name.
|
||
|
||
Sequential execution so later members can reference earlier cross-examinations.
|
||
|
||
This is where the real value emerges. Feynman does not just state his view — he has to explain why he disagrees with Socrates.
|
||
|
||
## Round 3: Synthesis
|
||
|
||
Each member states their final position in 100 words or fewer. No new arguments. Crystallization only.
|
||
|
||
Socrates gets exactly one question, then must state his position. This is the convergence gate that prevents the dialectic from spiraling.
|
||
|
||
## Anti-recursion enforcement
|
||
|
||
Socrates is the most dangerous member. His method is questioning, which means he can loop forever without committing to a position.
|
||
|
||
Three enforcement mechanisms prevent this:
|
||
|
||
The **hemlock rule**: if Socrates re-asks a question that another member has already addressed with evidence, the coordinator forces a 50-word position statement.
|
||
|
||
No more questions.
|
||
|
||
The **3-level depth limit**: question a premise, question the response, question once more. After 3 levels, Socrates must state his own position.
|
||
|
||
The **2-message cutoff**: if any pair of members exchanges more than 2 messages, the coordinator cuts them off and forces round 3.
|
||
|
||
These rules exist because the first version had no recursion limits. Socrates and Feynman would enter a questioning loop that consumed the entire context window.
|
||
|
||
no conclusion. just questions.
|
||
|
||
## Tie-breaking and consensus rules
|
||
|
||
The council uses 3 decision rules:
|
||
|
||
- **2/3 majority** = consensus. The dissenting position is recorded in a Minority Report section
|
||
- No **majority** = the dilemma is presented to the user with each position clearly stated. The council does not force artificial consensus
|
||
- **Domain expert weighting**: the member whose domain most directly matches the problem gets 1.5x weight
|
||
|
||
The minority report matters. Sometimes the dissenting view is the most valuable output.
|
||
|
||
It surfaces the risk that the majority position misses.
|
||
|
||
## Pre-defined triads for common domains
|
||
|
||
You do not need all 11 members for every question. The council ships 11 pre-built triads optimized for specific problem domains:
|
||
|
||
```text
|
||
DOMAIN TRIAD WHY
|
||
─────────────────────────────────────────────────────────
|
||
architecture Aristotle + Ada + Feynman classify → formalize → simplicity-test
|
||
strategy Sun Tzu + Machiavelli + Aurelius terrain → incentives → moral grounding
|
||
ethics Aurelius + Socrates + Lao Tzu duty → questioning → natural order
|
||
debugging Feynman + Socrates + Ada bottom-up → assumptions → formal verify
|
||
innovation Ada + Lao Tzu + Aristotle abstraction → emergence → classification
|
||
conflict Socrates + Machiavelli + Aurelius expose → predict → ground
|
||
complexity Lao Tzu + Aristotle + Ada emergence → categories → formalism
|
||
risk Sun Tzu + Aurelius + Feynman threats → resilience → empirical verify
|
||
shipping Torvalds + Musashi + Feynman pragmatism → timing → first-principles
|
||
product Torvalds + Machiavelli + Watts ship it → incentives → reframing
|
||
founder Musashi + Sun Tzu + Torvalds timing → terrain → engineering reality
|
||
```
|
||
|
||
Invocation:
|
||
|
||
```text
|
||
/council --triad architecture "should we split the monolith now or after Series B?"
|
||
/council --full "is this acquisition worth pursuing at 8x revenue?"
|
||
/council --members socrates,feynman,ada "why does our cache invalidation keep failing?"
|
||
```
|
||
|
||
\--triad selects a pre-built group.
|
||
|
||
\--full convenes all 11.
|
||
|
||
\--members lets you pick any 2-11 members manually.
|
||
|
||
No flag auto-detects the domain from your question and selects the matching triad \[E7\].
|
||
|
||
## What a council session produces
|
||
|
||
The output is not 11 separate opinions. It is a structured verdict:
|
||
|
||
```text
|
||
## Council Verdict
|
||
|
||
### Problem
|
||
should we migrate from REST to GraphQL for the mobile API?
|
||
|
||
### Council Composition
|
||
Architecture triad: Aristotle, Ada, Feynman
|
||
|
||
### Consensus Position
|
||
migrate the mobile-facing read endpoints to GraphQL.
|
||
keep REST for write operations and internal services.
|
||
|
||
### Key Insights by Member
|
||
- Aristotle: the problem is a category error — "migrate to GraphQL"
|
||
treats it as binary when the real question is which access
|
||
patterns benefit from graph traversal
|
||
- Ada: GraphQL's type system gives you compile-time guarantees
|
||
on the client that REST cannot match — but only for reads
|
||
- Feynman: the performance cost of GraphQL resolvers on write-heavy
|
||
paths is not theoretical. measure it. if N+1 queries appear
|
||
in staging, the abstraction is hiding real cost
|
||
|
||
### Points of Agreement
|
||
- mobile clients benefit from flexible queries (reduce over-fetching)
|
||
- write operations do not benefit from GraphQL's query model
|
||
- incremental migration is safer than full rewrite
|
||
|
||
### Points of Disagreement
|
||
- Aristotle wants a formal boundary definition before any migration
|
||
- Feynman wants a prototype with real latency measurements first
|
||
|
||
### Minority Report
|
||
none — consensus reached on hybrid approach
|
||
|
||
### Recommended Next Steps
|
||
1. prototype GraphQL gateway for 2 highest-traffic read endpoints
|
||
2. measure latency delta against current REST implementation
|
||
3. if delta is under 15ms p99, proceed with mobile read migration
|
||
```
|
||
|
||
The key difference from asking a single model: You get the disagreements explicitly.
|
||
|
||
Aristotle's "category error" reframe and Feynman's "measure it first" constraint are both surfaced. A single model averages these into one confident recommendation. The council keeps them separate so you can decide.
|
||
|
||
## Installation
|
||
|
||
The council is a Claude Code skill. Installation takes 30 seconds:
|
||
|
||
```text
|
||
git clone https://github.com/0xNyk/council-of-high-intelligence.git
|
||
cd council-of-high-intelligence
|
||
./install.sh
|
||
```
|
||
|
||
this copies 11 agent definitions to ~/.claude/agents/ and the coordinator skill to~/.claude/skills/council/SKILL.md.
|
||
|
||
Manual installation if you prefer:
|
||
|
||
```text
|
||
cp agents/council-*.md ~/.claude/agents/
|
||
mkdir -p ~/.claude/skills/council
|
||
cp SKILL.md ~/.claude/skills/council/SKILL.md
|
||
```
|
||
|
||
Requires Claude Code CLI with agent subagent support. CC0 licensed — use it however you want.
|
||
|
||
## When to use the council vs when not to
|
||
|
||
Use the council for complex decisions where trade-offs are real.
|
||
|
||
Architecture choices. Strategic pivots. Build-vs-buy. Pricing models.
|
||
|
||
Do **not** use it for questions with clear, correct answers.
|
||
|
||
Do **not** convene 11 thinkers to debate TypeScript vs JavaScript.
|
||
|
||
Do not use **\--full** when a triad covers the domain.
|
||
|
||
11 members consume significant context and API cost.
|
||
|
||
**The sweet spot**: Decisions where you already have an opinion but suspect you are missing something. The council surfaces what you are not seeing — structured, with the disagreements visible.
|
||
|
||
What is the last decision you made where a single confident answer hid the real trade-offs?
|
||
|
||
## Repository licensed under CC0 (public domain), github.com/0xNyk/council-of-high-intelligence
|
||
|
||
I started a private Telegram channel where I’ll be sharing insights and updates regularly:
|
||
|
||
[https://t.me/+GJ-FEpzcZrtmMTky](https://t.me/+GJ-FEpzcZrtmMTky) |