Making Claude, ChatGPT, and Gemini argue until they agree — and now, research together

Pranav Lakhwara — Mon, 06 Jul 2026 15:36:10 +0000

I pay for Claude, ChatGPT, and Gemini. The best answers I get come from making them check each other — and the worst workflow I had was copy-pasting between three tabs to do it.

auto-browser is my fix: an MCP server that attaches to a Chrome session I'm already logged into (over the DevTools Protocol — no API keys) and drives all three chat UIs in parallel. Claude Desktop orchestrates it through MCP tools.

Consensus with actual structure

Same prompt to all three; then cross-pollination rounds — each model sees the others' answers and revises. Rounds end with a line-anchored VERDICT: AGREE | DISAGREE vote. Consensus requires at least two unhedged AGREEs and zero DISAGREEs among models that succeeded. The edge cases got the real engineering: dissent stays sticky if the dissenter times out the next round, peer verdict lines are stripped before embedding (so a model quoting another can't cast its vote), and a timeout is never shown to the other models as if it were an answer.

To be precise about what this measures: convergence, not correctness. Three models agreeing can still be wrong — but where they disagree is reliably where I should be paying attention.

The new part: multi-provider deep research

v3.2.0 adds a research pipeline: hand it a batch of research prompts, and it routes each across providers, runs the providers' own deep-research modes, waits out the long runs, harvests the reports, and synthesizes a final per-task report from all of them.

Three provider quirks made harvesting genuinely fun to build:

ChatGPT renders deep-research reports inside a sandboxed cross-origin iframe. The main DOM shows zero assistant messages while a finished report sits right there on screen — naive scraping concludes the run failed. The fix is frame-aware extraction.
Claude puts the full report behind an expandable Document artifact; the message DOM only carries a preview. Harvest opens the artifact and takes the full text.
Gemini wants its research plan confirmed before it starts; the runner clears that gate automatically.

Deep research costs real money and real quota, so spend-safety is a design invariant, not a feature: a task that sent is never re-sent, chat URLs are preserved so a completed report can always be re-harvested for free, and a persisted quota ledger (e.g. Gemini's daily cap) plus cooldown detection means the queue waits instead of burning.

Model selection, because defaults are expensive

Every send resolves an explicit model — per-call → per-task → configured default — and never silently inherits whatever the tab last used. I learned that one the expensive way. Tests pin each provider's cheapest model by design.

Honest status

MIT. macOS is live-proven end to end; Windows/Linux Chrome paths exist but are untested. A 22-file Chrome-free unit suite runs in CI (Node 20/22); the live e2e gates need your own logged-in Chrome and never run in CI. And plainly: this automates provider web UIs, which may be restricted by their terms of service — it's built for your own personal, paid accounts, at your own risk. UI automation breaks when UIs change; there's a selector-registry override file for exactly that day.

Repo: https://github.com/mythicalhacker/auto-browser

Release notes: https://github.com/mythicalhacker/auto-browser/releases/tag/v3.2.0

I measured whether a Go skill actually makes AI agents write better Go (and open-sourced the benchmark)

Pranav Lakhwara — Tue, 30 Jun 2026 23:27:57 +0000

Coding agents write Go that compiles but isn't idiomatic: pre-1.22 habits, missing context, goroutines with no shutdown path, SQL built with fmt.Sprintf. In a one-off snippet you shrug it off; in a long autonomous run it's the difference between a clean build and a cascading failure. I built a skill to fix that — but I didn't want to claim it works. I wanted to measure it, the way only a compiled language lets you.

go-mastery is an Agent Skill: one always-on SKILL.md plus 36 lazy-loaded reference files (concurrency, errors, modern 1.22–1.26 APIs, security, gRPC, observability, MCP, eBPF, cgo, wasm, cloud-native). It runs in any SKILL.md-compatible agent — Claude Code, Cursor, Codex, and others.

The part I actually care about is go-mastery-evals, the open benchmark. Go is one of the few languages where correctness can be graded objectively — the toolchain does most of the judging. Every task is generated twice, with and without the skill, and graded by go build / go vet / go test / golangci-lint plus a hidden behavioral test the model never sees — generation and grading are separate processes, so the model only ever receives its own code plus tool diagnostics, never the test or the expected output. No LLM-as-judge. Grading is hermetic (vendored deps, GOPROXY=off) so it reproduces anywhere, and every case ships a must-pass and a must-fail fixture so the benchmark validates its own discrimination.

The result, across 54 cases, two vendors, six models, with zero in-domain regressions:

Anthropic:
Haiku +20.0
Sonnet +16.7
Opus +14.1

OpenAI:
GPT‑5.4‑nano +26.3
GPT‑5.4‑mini +20.7
GPT‑5.5 +12.6
(percentage-point gain in correctness, with vs without the skill)

The signature is the tell that it's real: the biggest lift lands on the smallest model and compresses as the model saturates. A weak model lacks the knowledge and the skill supplies it; a frontier model already has most of it, so on strong models the gain moves from correctness to a deterministic idiom-quality score instead. It also leads the other Go skills I benchmarked — JetBrains' go-modern-guidelines (+6.7 / +5.2 / +4.5 pp, never behind on a single case) and a leading community-authored one (+6.3 pp) — and stays neutral within sampling noise on an out-of-domain suite (third-party Aider-polyglot Go puzzles).

Why open-source the harness? Because a benchmark you can't run is just another claim. If you maintain a Go skill, run it through the identical gate — or try to beat these numbers. Both repos are MIT.

Inspect the source first, then install:

Skill: https://github.com/mythicalhacker/go-mastery
Benchmark + full methodology: https://github.com/mythicalhacker/go-mastery-evals

bashnpx skills add mythicalhacker/go-mastery

Claude Code plugin:

/plugin marketplace add mythicalhacker/go-mastery
/plugin install go-mastery@go-mastery

Honest caveats: the JetBrains head-to-head was samples=5 across all tiers; the community-skill comparison was samples=3 on Sonnet — both on an earlier skill build, so they're conservative. gpt-5.5-pro is excluded (served only via a different API). I'd genuinely value methodology critique — that's the most useful feedback I can get.

DEV Community: Pranav Lakhwara