tandemkit

TandemKit

Describe your goal, approve the spec, then step away — Claude and Codex loop together until it's right.

TandemKit is a Claude Code plugin that runs three sessions — Planner, Generator, and Evaluator — with two of them pairing Claude and Codex as independent reviewers. You are only needed at two points: during planning (questions and spec approval) and at review (when evaluation passes and you give feedback or call it done). Between those two points, the Generator implements and the Evaluator verifies in a tight loop, with no manual review or copy-pasting from you. In both the Planner and Evaluator sessions, Claude automatically launches Codex as a background task using the official Codex plugin, so two different models independently investigate and converge on a result — everything inside Claude Code.

Why TandemKit?

Who Is It For?

You have a Claude Max subscription (which includes Claude Code) and a ChatGPT subscription (which includes Codex). You work on tasks complex enough to warrant the extra cost — TandemKit is not recommended for simple, small, or mechanical tasks, since the multi-session loop uses more tokens than a regular Claude session.

The Reasoning

Anthropic's Harness article (March 2026) identified the core problem with agentic sessions: Claude stops too early. A single session anchors on its own work, declares "looks good!" prematurely, and misses real bugs. The fix is a separate evaluator session that verifies independently rather than rubber-stamping its own output.

The article puts it well: "tuning a standalone evaluator to be skeptical turns out to be far more tractable than making a generator critical of its own work." That separation is TandemKit's foundation. On top of that, it pairs Claude + Codex in both planning and evaluation — two models that approach problems differently. Codex tends to explore more files and dig into details Claude passes over, and in practice it finds real bugs Claude has already marked as passing.

Concrete verification tools matter too: the Harness article showed that without them, evaluators guess from surface impressions. /tandemkit:init sets up project-type-specific tools (build, run, navigate, screenshot) so the Evaluator can do what a human reviewer would.

How It Works

All three sessions are Claude Code sessions. Claude orchestrates everything — including launching Codex as a background task when a second opinion is needed.

USER  ── step 1: planning
  │
  └──> [1] Planner Session
             Claude ───────────────► Codex (launched by Claude, runs in background)
              │    ◄──── findings ── │
              └─────── converge ─────┘
                            │
                         Spec.md ◄── you review and approve before continuing

USER  ── step 2: open both sessions in parallel — they coordinate autonomously from here
  │
  ├──> [2] Generator Session (reads Spec.md)
  │          Claude implements, commits at milestones
  │
  └──> [3] Evaluator Session
             Claude ───────────────► Codex (launched by Claude, runs in background)
              │    ◄──── findings ── │
              └─────── converge ─────┘
                            │
                            ├──> FAIL ──> Generator fixes & resubmits ──> back to [3]
                            └──> PASS ──> Review Briefing ──> User

Three Claude Code sessions for the entire mission:

1. Planner — Claude investigates the codebase and launches Codex in the background to do the same. Both produce independent findings. Claude reads Codex's results, merges them, and they iterate until converged. You answer questions and approve the final spec.
2. Generator — Claude implements against the spec, committing at milestones. Fully autonomous — no Codex needed here since the Evaluator handles verification.
3. Evaluator — Claude evaluates independently while Codex does the same in the background. They converge on a verdict. On FAIL, the Generator fixes and resubmits. On PASS, you review the result.

You are active during planning, then step away while Generator and Evaluator loop autonomously. When evaluation passes, you receive a Review Briefing — approve it or give feedback, and the loop continues with updated requirements until you're satisfied.

The structure mirrors pair programming: the Generator is the driver (implementing, focused on the code), and the Evaluator — Claude and Codex together — is the navigator (reviewing, catching mistakes, thinking ahead). You step in as navigator at two points: spec approval and final review.

Model and effort settings: Codex's reasoning effort is configurable per project — /tandemkit:init asks during setup and stores it in Config.json under codex.effort. Default is high (very thorough, friendly to personal-account rate limits); pick xhigh if you need maximum reasoning quality and don't mind hitting rate limits sooner, or medium for routine missions where you want to save tokens. Claude runs at whatever model and effort level you have configured locally — Sonnet 4.6 is the minimum recommended model; Opus produces better results at higher cost. Both are yours to tune based on task complexity and how much you want to spend.

Installation

Start Claude Code, then run:

/plugin marketplace add FlineDev/Marketplace

/plugin install tandemkit

/tandemkit:init

This sets up role files and verification tools for your project. Run once per project.

If you're in an active session, run /reload-plugins to activate immediately. TandemKit is part of the FlineDev Marketplace — see the full list of available plugins there.

[!TIP] Automatic Updates: By default, third-party plugins don't auto-update. To receive new features and fixes:

1. Type /plugin and press Enter
2. Switch to the Marketplaces tab
3. Navigate to FlineDev and press Enter
4. Press Enter on Enable auto-update

Dependencies

• Claude Code with the codex-plugin-cc plugin installed (Claude uses this to invoke Codex internally)
• Codex CLI authenticated (/codex:setup to verify)
• python3 (used by coordination scripts)
• watchman (brew install watchman) — for file-watching between sessions

Quick Start

The only command you need to remember is /planner — describe what you want to build, and Claude takes it from there. After planning, it presents the exact commands to copy-paste for the Generator and Evaluator sessions.

Commands

Evaluation Strategies & Customization

Why verification tooling matters

An evaluator that can only read code will miss real bugs. The Harness article demonstrated this directly: "the evaluator used the Playwright MCP to click through the running application the way a user would, testing UI features, API endpoints, and database states." Without concrete tools, evaluation degrades to guessing.

/tandemkit:init detects your project type and recommends the right verification tools:

The key principle: the Evaluator should be able to do whatever a human reviewer would do — build, run, navigate, screenshot, test. The more verification paths available, the harder it is for bugs to slip through.

Both XcodeBuildMCP and browser-use ship an official Claude Code skill that primes the Evaluator with the right commands and patterns. /tandemkit:init guides you through installing the right tools for your project type.

Strategy reference files

Evaluation strategies are documented in skills/evaluator/strategies/:

• ApplePlatform.md — XcodeBuildMCP setup for iOS/Simulator + Peekaboo CLI setup for macOS runtime UI automation, SwiftUI previews, accessibility-identifier best practices
• Android.md — Android CLI setup, Android Skills install, emulator + screenshot + layout workflow, Flutter integration
• Web.md — browser-use CLI setup, token-optimized extraction patterns
• Web-Playwright.md — Playwright MCP fallback for web projects
• CLI.md — test suites, command-line verification, library testing
• Domain.md — canonical case testing, consistency checks, fabrication detection

These files are what /tandemkit:init uses to configure your Evaluator. PRs with new strategies or improvements to existing ones are welcome — different project types benefit from different verification approaches.

Project role files

During init, TandemKit creates three role files in your project's TandemKit/ folder:

These are your customization points. Edit them any time to refine how each session works for your project. For example, add domain-specific test cases to Evaluator.md, point the Planner at additional documentation, or configure the Generator's commit conventions.

Hardened Evaluator system prompt