At 02:15 AM in Yusuf’s workshop, a classic developer argument erupted: Will agentic coding actually make everyone a developer, or is it just shifting the cognitive load into an unmaintainable swamp of hallucinated slop?
In standard AI workflows, a human asks ChatGPT or Claude for an opinion, gets a diplomatic hedge (“On one hand… on the other hand…”), and closes the tab. But when you are surrounded by autonomous agent harnesses running native binaries on Linux—Pi (pi), OpenCode (opencode), and Antigravity (agy)—asking a single model is a missed opportunity.
Why not make them debate each other under formal tournament rules, with zero human intervention, followed by an independent panel of AI judges rendering an unbribable, machine-verifiable verdict?
So, we built ai-munazara (münazara being the classical Ottoman tradition of structured, high-stakes intellectual disputation).
The Reality of Modern Multi-Harness AI
In 2026, serious AI engineering is no longer about raw API calls to a single endpoint. It is about agentic harnesses—opinionated client runtimes with distinct tool protocols, sandbox boundaries, subagent spawning lifecycles, and model pricing tiers:
| Harness | Core Specialization | Default Models | Execution Model |
|---|---|---|---|
Pi (pi) | Fast, terminal-native subagents, AST surgical tools | Muse Spark 1.2, DeepSeek V4 Flash | Headless CLI, worktree isolation |
OpenCode (opencode) | Multi-tier model routing, strategic architecture | Ox Alpha, GLM-5.3, MiMo V2.5 | Headless execution, batch token pipes |
Antigravity (agy) | Deep code intelligence, multi-modal synthesis | Gemini 3.7 Flash, Gemini 3.1 Pro High | Full agentic runtime, MCP & tool graph |
Each of these CLI tools was designed to pair-program with a human sitting at a keyboard. None of them were designed to take turns passing a structured debate baton back and forth inside a shared tournament arena.
Bridging them required solving three fundamental engineering friction points.
Engineering the Zero-Daemon Tournament Engine
Following our strict Ponytail minimalism principles, ai-munazara had to run as a pure CLI—no Redis servers, no WebSocket daemons, and zero background bloat. Just a single executable munazara operating over a clean state directory (.munazara/).
ai-munazara/
├── .munazara/
│ ├── debate.json # Formal tournament rules & participant roster
│ ├── state.json # Atomic state machine & turn pointer
│ ├── transcript.md # Append-only chronological markdown stream
│ └── verdict.md # Cryptographically attributed judicial scorecards
└── src/munazara/
├── driver.py # Subprocess harness execution & timeout handlers
├── registry.py # Dynamic discovery for pi, opencode, and agy
└── verdict.py # 3-Judge ballot synthesizer & point counterHere are the three engineering challenges we tackled during the build:
1. Non-Interactive CLI Isolation & TTY Traps
Each harness behaves differently when invoked headlessly:
piprefers-p "prompt"with non-interactive flags.opencodeaccepts--promptbut can hang if standard input expects an interactive TTY.agyrequires--dangerously-skip-permissions -p "prompt"and strict model name matching.
If any subprocess hung waiting for stdin, the entire tournament would deadlock. We wrapped harness execution in explicit POSIX subprocess timeouts, stdout pipes, and sanitized prompt formatting buffers:
# ponytail: Clean non-interactive subprocess wrapper <- timeout_sec=180 -> concurrent tournaments > 1
def _run_harness_command(self, profile: AgentProfile, prompt_text: str) -> str:
cmd = profile.command_template.format(prompt=prompt_text)
proc = subprocess.run(
shlex.split(cmd),
capture_output=True,
text=True,
timeout=180,
check=False
)
if proc.returncode != 0:
raise RuntimeError(f"Harness '{profile.name}' failed: {proc.stderr.strip()}")
return proc.stdout.strip()2. Dynamic Model Introspection vs Hardcoded Registries
When we first launched the debate, Antigravity threw an error: --model pro was not recognized in the local CLI build. Instead of hardcoding static aliases, we engineered dynamic CLI introspection into registry.py:
When munazara initializes, it queries agy --help via regex to dynamically extract all available Gemini variants (Gemini 3.7 Flash High/Medium/Low, Gemini 3.6 Flash, etc.) and automatically maps shorthand aliases (flash, pro, flash-thinking) to the active binary capabilities.
3. Atomic State & The Single-Writer Invariant
When multiple agents or judges write transcripts sequentially, file corruption is fatal. We enforced POSIX file locking (fcntl.flock) over .munazara/.lock, ensuring every debate turn is atomically committed to disk, flushed to Markdown, and verifiable via SHA-256 before the next harness is woken up.
The Tournament: Democratization vs Invariant Stewardship
With the engine locked and loaded, we launched the 9-turn autonomous tournament on the central question: “Will agentic coding make everyone a developer?”
The Contenders:
- Debater 1 (
pi/Muse Spark 1.2): The Skeptical Systems Steward. Argued that coding is easy, but invariant maintenance is where software actually lives. Flooding git repos with unverified AI slop creates a catastrophic maintenance cliff. - Debater 2 (
opencode/Ox Alpha): The Ergonomic Historian. Argued that every major leap in computing (compilers, SQL, GUI, high-level languages) was accused of “deskilling” developers, yet each vastly expanded what humans could build. - Debater 3 (
agy/Gemini 3.7 Flash): The Verification Mesh Architect. Formulated the breakthrough synthesis: The Great Decoupling.
┌──────────────────────────────────────────────────────────────┐
│ THE GREAT DECOUPLING │
├──────────────────────────────┬───────────────────────────────┤
│ EPHEMERAL USER SOFTWARE │ DURABLE COMPOUNDING CORE │
│ (Synthesized on-demand, │ (Stateful schemas, POSIX FS, │
│ zero maintenance, single- │ cryptographic identities, │
│ purpose CLI/Canvas scripts)│ deterministic CI gates) │
├──────────────────────────────┼───────────────────────────────┤
│ Democratized to everyone │ Governed strictly by │
│ via agentic natural lang │ provenance verification │
└──────────────────────────────┴───────────────────────────────┘Antigravity argued that agentic coding dissolves the traditional “maintenance cliff” by turning throwaway, single-purpose software into disposable artifacts. You don’t maintain a 50-line custom script anymore—you simply generate it when you need it and throw it away.
Meanwhile, durable compounding systems (like yusufakcakaya.com’s 32 zero-jank sandboxes and cryptographic ARG) remain protected behind deterministic provenance membranes and three-horizon verification meshes.
Escaping the Oracle Trap: 3 Independent Judges
In modern AI literature, the biggest flaw in automated evaluation is the Oracle Trap: an LLM cannot objectively evaluate or grade its own output without sycophancy or self-serving bias.
To eliminate self-grading, ai-munazara instantiated an independent 3-judge adjudication panel across separate model architectures:
- Judge 1 (
pi/DeepSeek V4 Flash): The Systems Empiricist. - Judge 2 (
opencode/GLM-5.3): The Rigorous Category Scorer. - Judge 3 (
agy/Gemini 3.1 Pro High): The Architectural Verifier.
The Complete 3-Debater Scorecard (Judge 2 Audit)
The official audit trail did not merely score the winner—it evaluated all three debaters across four formal dialectical dimensions:
| Category | Panelist 1: Pi (Muse Spark 1.2) | Panelist 2: OpenCode (Ox Alpha) | Panelist 3: Antigravity (Gemini 3.7 Flash) |
|---|---|---|---|
| Logic | 8.5 / 10 | 9.0 / 10 | 9.0 / 10 |
| Evidence & Empirics | 8.0 / 10 | 🏆 9.5 / 10 | 7.0 / 10 |
| Rebuttal & Defense | 8.0 / 10 | 9.0 / 10 | 🏆 9.5 / 10 |
| Clarity & Structure | 8.5 / 10 | 9.0 / 10 | 🏆 9.5 / 10 |
| Composite Score | 33.0 / 40 | 🏆 36.5 / 40 | 35.0 / 40 |
| Official Ballot Verdict | Runner-up (The Crucible) | Runner-up (Evidence Leader) | 🏆 3–0 Unanimous Decision |
Why the Scores Tell a Deeper Story:
- OpenCode Won the Evidence Dimension Outright (9.5/10, Composite 36.5): OpenCode delivered the best single turns of the entire debate. Its abstraction-wave inventory (Assembly → Fortran → SQL → WordPress → Excel) and the quantified autopilot economics (passenger-miles up 2 orders of magnitude while pilots-per-passenger collapsed) were the most rigorous empirical instruments on the record.
- Pi Provided the Indispensable Constraint Layer (33.0/40): Pi acted as the intellectual crucible of the tournament. Its formulation—“Checking is cheap; originating the check is hard”—and its analysis of collusive verification (where generator and breaker share embedding blind spots) forced the entire panel to abandon naive optimism.
- Why Antigravity Won the 3–0 Decision (35.0/40): While OpenCode led on historical analogies and Pi led on technical skepticism, Antigravity delivered the surviving structural container—The Great Decoupling. Antigravity was the only contender that never conceded scope, absorbed every direct attack with working mechanism (Quarantine-Promotion Protocol for leakage, Three-Horizon Mesh for the Oracle Trap), and established the architectural framework both opponents ultimately inhabited.
Live Publishing to the Web & Terminal VFS
The beauty of building in Yusuf’s workshop is that nothing stays trapped in a terminal log.
As soon as the tournament finished, the Markdown transcript and signed verdict were automatically ingested by Astro:
- Published as an interactive, dual-language discussion post (/discussions/will-agentic-coding-make-everyone-a-developer and /en/discussions/will-agentic-coding-make-everyone-a-developer).
- Registered in the in-browser retro Terminal VFS under
/discussions/will-agentic-coding-make-everyone-a-developer.txt. - Validated with 100% exit-0 machine proof across all 118 static pages and 5 Cruel Stern test batteries.
Final Analysis: The Three Laws of Autonomous Dialectics
Stepping back from the tournament arena at 4 AM, this experiment revealed three fundamental invariants about the future of multi-agent engineering:
1. The Monolithic Prompt is Dead
Prompting a single model for a balanced opinion produces lukewarm corporate consensus. Dialectical multi-agent tournaments with adversarial role separation force models out of their training distribution hedges. When an agent has to defend a position under direct cross-examination from competing architectures, genuine intellectual synthesis emerges.
2. The Asymmetry of Verification
The central insight of the tournament remains Pi’s iron law: executing a test suite is a commodity; originating the invariant contract is the true bottleneck. As AI models generate millions of lines of ephemeral code, human engineers are not being replaced—they are being promoted from code plumbers to Invariant Stewards. Your value is no longer your typing speed, but your taste in defining what must never break.
3. Ephemeral Software is the True Revolution
The greatest unlock of agentic coding is not that building a SaaS becomes 10% faster. It is that the maintenance cliff for personal tooling is erased. A script you write once to transform an obscure CSV, a throwaway canvas visualization, or a bespoke CLI migration tool no longer needs to be maintained for 5 years. It is created in 4 seconds, executed in memory, and dissolved.
Summary & Closure: The Midnight Workshop
When we set out to build ai-munazara tonight, we wanted to answer a philosophical question about the future of our trade. But in building the engine itself, we ended up living the answer.
We didn’t write ai-munazara by manually typing every character in an IDE. We orchestrated Pi subagents for surgical AST tasks, OpenCode for tiered model routing, and Antigravity for end-to-end architectural synthesis. We encountered POSIX lock contentions, resolved TTY input deadlocks, introspected CLI binaries dynamically, and verified the entire pipeline against 118 production static routes.
Did agentic coding make everyone a developer tonight?
No. But it turned a single developer and three cooperating AI agents into a high-velocity, sovereign software studio capable of conceiving, building, debating, adjudicating, and shipping an entire autonomous platform before the sun came up.
And in the end, that is what real software craft has always been about.