trio-dev

Multi-model development workflow. Claude is the main agent and orchestrator. Codex (GPT) plans and writes adversarial tests. Gemini designs (UI, schemas, flow diagrams). Both cross-review Claude's code. All four share state through .trio/ files.

v0.2.0 changed the dispatch model. Claude now calls ~/.claude/bin/*.sh wrappers directly — no Antigravity Manager View clicks. Sub-models run end-to-end from a single session.

How it works

┌─────────────────────────────────────────────────────────────┐
│ User: /trio-build "feature description"                     │
└──────────────────────────┬──────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────────┐
│ Claude (orchestrator)                                        │
│  ├── preflight: every wrapper in ~/.claude/bin/ exists?      │
│  ├── writes .trio/brief.md                                   │
│  └── issues two parallel Bash calls:                         │
└──────────────┬──────────────────────────┬───────────────────┘
               │                          │
               ▼                          ▼
    ~/.claude/bin/trio-design.sh  ~/.claude/bin/trio-plan.sh
               │                          │
               ▼                          ▼
          Gemini API                  Codex CLI
               │                          │
      .trio/design.md           .trio/plan.md + tests.md
               │                          │
               └────────────┬─────────────┘
                            ▼
                  Claude reads, summarizes
                  implements, commits per task
                            │
                            ▼
              ~/.claude/bin/trio-review.sh (×2 parallel)
                            │
               ┌────────────┴────────────┐
               ▼                         ▼
          Gemini API                 Codex CLI
               │                         │
    .trio/review-gemini.md     .trio/review-gpt.md
                            │
                            ▼
                     /trio-finalize

Commands

Command	What it does
/trio-build <desc>	Full workflow: brief → design + plan (parallel) → code → review (parallel)
/trio-design <desc>	Design step only — dispatches Gemini, produces .trio/design.md
/trio-plan <desc>	Plan step only — dispatches Codex, produces .trio/plan.md and .trio/tests.md
/trio-code	Code step — reads plan + design, Claude implements, dispatches review
/trio-continue	Recovery from interruption (normally unused in v0.2.0 happy path)
/trio-finalize	Merge the two reviewer verdicts and decide fix-or-ship
/trio-test	Liveness check — dispatch tiny prompts to both sub-models, report who/what they are

Skills

Skill	Role	Dispatched how
trio-orchestrate	Sets up context, runs wrappers, verifies handoffs	Claude, inline
trio-design	UI mockups, schemas, flow diagrams, visual specs	~/.claude/bin/trio-design.sh → Gemini
trio-plan	Requirements, acceptance criteria, edge cases	~/.claude/bin/trio-plan.sh → Codex
trio-code	Implementation following plan + design	Claude, inline
trio-review	Cross-AI code review, two reviewers parallel	~/.claude/bin/trio-review.sh {gemini,codex}

Shared state: .trio/ directory

Every run creates:

.trio/
├── brief.md            # Shared input — what we're building
├── design.md           # Gemini output
├── plan.md             # ChatGPT output — requirements, phases
├── tests.md            # ChatGPT output — acceptance tests, edge cases
├── implementation/     # Claude output — code + commits
├── review-gemini.md    # Gemini reviewer verdict
└── review-gpt.md       # GPT reviewer verdict

Each agent reads what it needs, writes its output. Claude merges everything and handles Git commits.

Install

Two steps: clone the plugin, then run the installer. The installer symlinks commands + skills into .claude/commands and .claude/skills so they show up in slash-command pickers (Claude Code, Antigravity, etc.).

Local install — recommended (current project only)

# From your project root
git clone https://github.com/taneltaluri/trio-dev.git .claude/plugins/trio-dev
bash .claude/plugins/trio-dev/install.sh

On Windows:

git clone https://github.com/taneltaluri/trio-dev.git .claude\plugins\trio-dev
powershell -ExecutionPolicy Bypass -File .claude\plugins\trio-dev\install.ps1

Windows symlinks need Developer Mode (Settings → Privacy & Security → For developers) or admin PowerShell. If neither works, open install.ps1 and set $UseCopy = $true to fall back to file copies.

Global install (all projects)

# macOS / Linux
git clone https://github.com/taneltaluri/trio-dev.git ~/.claude/plugins/trio-dev
cd ~ && bash ~/.claude/plugins/trio-dev/install.sh

# Windows (PowerShell)
git clone https://github.com/taneltaluri/trio-dev.git $env:USERPROFILE\.claude\plugins\trio-dev
cd $env:USERPROFILE
powershell -ExecutionPolicy Bypass -File .claude\plugins\trio-dev\install.ps1

Restart Claude Code and run /trio-build to verify.

Update later

cd .claude/plugins/trio-dev   # or ~/.claude/plugins/trio-dev for global
git pull
# no need to re-run install.sh — symlinks already point to the plugin dir

Copy-mode caveat (Windows): if you set $UseCopy = $true in install.ps1 (because Developer Mode and admin PowerShell both aren't available), the files under .claude/commands and .claude/skills are copies, not symlinks. A git pull does not refresh them — re-run install.ps1 after every pull.

Uninstall

bash .claude/plugins/trio-dev/uninstall.sh
rm -rf .claude/plugins/trio-dev   # optional: remove plugin itself

Using it

0. Verify your dispatch stack is alive: /trio-test. You should see Gemini and Codex each self-identify in three lines. If that fails, the rest of the plugin fails too — start at INSTALL.md "Prerequisites".
1. Run /trio-build "your feature description".
2. Claude writes .trio/brief.md, runs preflight, then dispatches trio-design.sh and trio-plan.sh in parallel by issuing two Bash calls in one message. You see the streaming output from each wrapper (via ~/.cache/trio-dev/gemini/latest.log and ~/.cache/trio-dev/codex/latest.jsonl if you want to tail them live).
3. When both finish, Claude summarises design + plan + top edge cases and asks you to confirm before code changes begin.
4. On confirmation, Claude implements the feature task by task, committing atomically (trio(code): <task>), running tests per task.
5. When code is done, Claude dispatches trio-review.sh gemini and trio-review.sh codex in parallel. Both reviewers see the same implementation summary and git log, but with different role hints in the system prompt.
6. Run /trio-finalize. Claude merges verdicts (strictest wins), lists Critical + Major issues deduplicated by file:line, and asks whether to fix or ship.

Manual fallback — Antigravity Manager View

If a wrapper is broken or you want to override a sub-model's output, you can still dispatch a role manually from Antigravity Manager View and write the output file yourself:

Role	Skill	Output
Designer	trio-design	.trio/design.md
Planner	trio-plan	.trio/plan.md + .trio/tests.md
Reviewer (Gemini)	trio-review	.trio/review-gemini.md
Reviewer (GPT)	trio-review	.trio/review-gpt.md

After Manager View writes the file, run /trio-continue (if mid-build) or /trio-finalize (if mid-review). This path is last-resort — the wrappers are the supported primary flow.

Configuration

Per-project context — .trio/project-context.md

Drop this file in any project's .trio/ directory and every wrapper will include it automatically in the sub-model's brief. Good contents:

• Stack (language, framework, ORM, test runner)
• Conventions (naming, commit format, import order)
• Constraints (GDPR, offline, mobile-first)
• Non-goals (what we explicitly do not want)

Template at templates/project-context.example.md.

Model selection — via env vars to the wrappers

The wrappers read environment variables for model choice:

• GEMINI_MODEL — passed to ask-gemini.sh. Default: gemini-2.5-pro.
• CODEX_REASONING — passed to ask-codex.sh. Default: medium (values: low, medium, high).

Set them per-shell or per-invocation:

GEMINI_MODEL=gemini-2.5-pro /trio-design "..."
CODEX_REASONING=high /trio-plan "..."

.trio/config.json is reserved for future plugin-level config and is not yet consumed — see templates/config.example.json for the forward-looking schema.

License

MIT