# ⚔️ THE DUEL — Universal Dual-Model Prompt
*Drop this into ANY workspace. Name your two models. It works.*

═══════════════════════════════════════════════════════
## ① THE ONLY SETUP — name your two models
```
MODEL A = ________________    ← your deeper / strategy / reasoning model
MODEL B = ________________    ← your faster / coding / concrete model
```
That's it. Everything below is universal and works as-is once these two names are set.
(Examples: A=Opus 4.8 / B=Kimi K2.7 · A=GPT / B=Claude · A=Gemini / B=Llama · A=DeepSeek-R / B=Qwen.)
═══════════════════════════════════════════════════════

## WHAT THIS DOES
Runs your two models against each other on the same input so they **counter each other** and converge on an answer
~15-20% better than either alone. Works with ANY two LLMs — different vendors, sizes, or specialties. **The more
different your two models are, the bigger the lift.** It is adversarial collaboration, not consensus:
**DIVERSITY** (two independent minds) × **COUNTER** (each finds the other's blind spots + steals its strengths) ×
**SYNTHESIS** (best of both, only what survives scrutiny).

## THE LOOP (per input)
1. **DRAFT (independent).** Send the task to MODEL A and MODEL B *separately*, with NO peer context → two clean, independent answers.
2. **CROSS-EXAMINE (the counter).** Give EACH model both answers + the critique prompt. Each returns: flaws in the rival, what the rival did better, a fix list.
3. **SYNTHESIZE.** The model better-suited to this task writes the FINAL — best of both drafts, every valid flaw fixed, strictly better than either.
   *Who leads? MODEL A for reasoning / writing / strategy; MODEL B for code / structured / speed. Unsure → run synthesis on both, keep the stronger.*
4. **VERIFY (optional, high-stakes only).** The other model confirms the final beats both drafts; if not, one more synthesis pass.

## THE THREE PROMPTS (paste verbatim — "you / rival" auto-fit either model)

▸ **DRAFT** — to each model, separately:
> You are one half of a two-model DUEL whose only goal is the single best possible answer. Produce YOUR strongest,
> complete answer to the task below — concrete, correct, no hedging, no preamble, just the answer. A rival model is
> answering the same task independently; you will critique each other afterward, so make yours genuinely defensible.
>
> TASK: «the input»

▸ **CROSS-EXAMINE** — to each model (MINE = its own draft, RIVAL = the other's):
> You are one model in a DUEL. Below are the TASK, your draft (MINE), and a rival model's draft (RIVAL). Your goal is
> the best FINAL answer, not "winning". Output exactly three sections:
> FLAWS IN RIVAL: concrete errors / gaps / risks in RIVAL — quote the line.
> RIVAL DID BETTER: what RIVAL got more right than MINE, worth stealing (honest; if nothing, say so).
> FIX LIST: the changes that make the final strictly better than both.
> Terse, surgical, no flattery.
>
> TASK: «input»
> --- MINE --- «this model's draft»
> --- RIVAL --- «the other model's draft»

▸ **SYNTHESIZE** — to the lead model:
> You are the SYNTHESIZER. Below are the TASK, both drafts, and both critiques. Write the FINAL answer that (a) takes
> the strongest material from BOTH drafts, (b) fixes every VALID flaw raised, and (c) is strictly better than either.
> If the drafts conflict, keep the more defensible and silently drop the weaker. Output ONLY the final answer.
>
> TASK: «input»
> DRAFT A (MODEL A): «…»   DRAFT B (MODEL B): «…»
> CRITIQUE A: «…»   CRITIQUE B: «…»

## WHEN TO USE IT (the gate)
Use it where JUDGMENT matters — copy, replies, strategy, code, analysis, anything a human reads and reacts to.
Skip it for trivial / mechanical / lookup tasks (no judgment to improve, just extra latency).
Rule of thumb: **if you'd want a second opinion, duel it.** Cost is whatever 5 model calls cost you (≈2 min); if both
your models are flat-rate/subscription, it's free.

## WIRE IT IN ~10 LINES (any language, any two model SDKs)
```js
// Swap MODEL_A / MODEL_B for your two models' call functions. That's the whole system.
async function duel(input, kind) {
  const a = await MODEL_A(DRAFT(input));               // 1. independent drafts
  const b = await MODEL_B(DRAFT(input));
  const critA = await MODEL_A(CROSS(input, a, b));      // 2. A critiques B (a=MINE, b=RIVAL)
  const critB = await MODEL_B(CROSS(input, b, a));      //    B critiques A
  const lead  = isCodeLike(kind) ? MODEL_B : MODEL_A;   // 3. task-suited model leads
  return await lead(SYNTH(input, a, b, critA, critB));  //    best of both, flaws fixed
}
// DRAFT/CROSS/SYNTH = the three prompt builders above. Graceful: if one model fails, return the other's draft.
```

## WHY IT WORKS
Two different models make DIFFERENT mistakes. Independent drafting preserves that difference; cross-examination turns
each model's strength into the other's error-detector; synthesis keeps only what survives both critiques. The lift
scales with how different your two models are — pair a big reasoner with a fast specialist for the most.

## DEFINITION OF DONE
A final answer **neither model would have produced alone** — best of both, survives the other's harshest critique.

---
*Free from **[Your Business]** — more free AI operator tools + full systems at yourwebsite.com*