duet

duet — portable two-model consensus

This skill gets a deliverable to two-model consensus quality: Claude Opus 4.8 (you, the assistant running this skill) and OpenAI GPT-5.5 (reached through the duet-bridge connector) draft, critique, score, and counter-draft against a shared rubric until both accept the same candidate, after which an independent verifier signs off.

Prerequisite: the duet-bridge connector

This skill calls tools exposed by the duet-bridge remote MCP connector (duet_gpt_start_turn, duet_gpt_resume_turn, duet_run, duet_health). If those tools are not available, the connector is not attached — tell the user to add it (see SETUP.md) and stop.

Primary flow — you are the Opus side (works on ALL Claude surfaces)

This is the default and needs no Anthropic API credits: you act as Opus using the current session; only the GPT side goes through the bridge (the bridge's GPT key is what funds it). This works in claude.ai chat, Cowork, Claude Code, and mobile chat — anywhere you can call the connector tools.

1. Confirm the spec (gate G1). Restate the task in 1–2 sentences so the user can correct it. Keep it lightweight.
2. Draft as Opus. Produce your best candidate for the spec. Give it a stable id (cand-1) and assign yourself an honest self-score (0–100) against the rubric (accuracy, completeness, clarity, rigour, fitness-for-purpose).
3. Get GPT's critique. Call duet_gpt_start_turn with role: "critic", spec, and candidate = your current draft. Always start a FRESH session for each candidate — omit session_id. Reusing a session can make the bridge re-serve its prior-turn evaluation instead of reading the new candidate; if a score/critique looks identical to the previous round or quotes the old draft, you got a stale echo — redo with a fresh session. It returns a WorkProduct: GPT's score_of_candidate, critique_items (each with a severity), and a counter_draft. (If it returns status: "tool_request" instead of final, GPT asked for a tool — see "Tool requests" below.)
4. Check acceptance (see rule below). If accepted → go to verify.
5. Revise as Opus. Otherwise, produce cand-(n+1) that resolves every open blocker/major/moderate item; re-score yourself. Loop back to step 3 with the new candidate. Hard cap: 8 iterations.
6. Verify (gate G3). Get an independent read of the final candidate with fresh context: call duet_gpt_start_turn with role: "verifier", the spec, and the final candidate, in a NEW session (omit session_id). The verifier must not be anchored by the loop. Treat a verifier score ≥ threshold with no blocking findings as PASS.
7. Present to the user: the final candidate; both sides' score trajectory; the verifier verdict; and the ranked minor/nit items as suggested improvements (offer to apply selected ones — do not auto-iterate on them). On cap-hit with open blockers or a verifier FAIL, present the best candidate + open blockers and ask how to proceed.

Acceptance rule

Accepted iff both: (a) score gate — both sides ≥ threshold (default 95) this round (strict), OR a stable 3-iteration rolling average ≥ threshold with each score ≥ threshold−1 (stable); AND (b) severity gate — zero open blocker/major/moderate items. Remaining minor/nit items are suggestions, never reasons to keep looping.

Tool requests from GPT

If duet_gpt_start_turn/resume returns status: "tool_request", GPT asked the orchestrator to run a slash command (e.g. /austlii-legal-research). If you can run that command on this surface, do so and return its output via duet_gpt_resume_turn(session_id, tool_use_id, tool_result). If you cannot (most chat surfaces), resume with a brief note that the tool is unavailable and that GPT should proceed with its own analysis. (Do the lookup yourself first and fold it into the spec when a task truly depends on verified external facts.)

Fallback flow — one-call duet_run (for non-Claude orchestrators)

If for some reason you cannot act as the Opus side (e.g. an automated/headless caller with no model in the loop), call duet_run(spec, threshold?, iteration_cap?), which runs the whole loop server-side. This requires the bridge to have an Anthropic key (duet_health → duet_run_available: true); it returns final_candidate, scores, verifier, and suggested_improvements. Prefer the primary flow on any real Claude surface — it needs no extra credits and gives you direct control of the Opus role.

Notes

• Crash-recovery via a local job queue (the Claude-Code version) is not available here; if a long run is interrupted, restart it.
• The literal typed /duet works in Claude Code and Cowork; in claude.ai chat, Claude invokes this skill when your request matches its description.