fusionthink

Files (1)

• SKILL.md

SKILL.md (first lines)

# Fusionthink

Two independent reviewers from different vendors read the same brief. You
verify what they say against the actual code, push back where it does not hold
up, and let each vendor settle the other's disputes.

**Requires the sibling skills `claude-agent` and `codex-agent`, plus both
vendor CLIs (`claude` and `codex`) installed and authenticated.** Without both
lanes this skill has no reason to exist — use a single reviewer instead.

## Detect intent

Read the user's request and determine which mode applies:

- **Review** — the user wants opinions, analysis, feedback. Phrases like
  "review this", "what do you think", "check this", "analyze", "find issues".
  You report findings. The user decides what to act on.

- **Converge** — the user wants the artifact fixed until it's done. Phrases
  like "fix this", "make it ready", "keep going until done", "exhaustively
  fix", "fix until both agents agree", "make edits and review until LGTM".
  You edit the artifact, re-review, and loop until both agents say it's ready.

If ambiguous, default to **review**. The user can always say "now fix it."

## Figure out the subject

Read, grep, diff — whatever it takes to understand what the user wants
reviewed or fixed. Could be a plan file, source files, uncommitted changes,
a design question, anything. Compose a single review/analysis prompt that
gives the agent enough context to do real work — point it at the actual
files, explain what we're looking at and why, and tell it to read the code
itself.

**Do not enter plan mode. Do not pre-plan phases. Just start.**

## Dispatch both agents in parallel

Write the prompt to one temp file with a **unique stub** so concurrent runs
cannot collide — for example `fusionthink-<timestamp>-<random>.md` in the
system temp directory. Both agents read that same file.

Launch both wrappers **in the same message**, both in the background, using
`PROMPT_FILE` so the brief reaches each reviewer byte-exact on stdin:

- **claude**: `PROMPT_FILE=<brief> node "~/.claude/skills/claude-agent/scripts/claude-agent.mjs"`
- **codex**: `PROMPT_FILE=<brief> node "~/.claude/skills/codex-agent/scripts/codex-agent.mjs"`

Both get the **identical prompt**. Both reviewers are full independent agents
over the same brief.

## Wait for BOTH agents, then collect output

**Wait for both background tasks to complete before proceeding.** Do not
start verification after only one returns — the second agent's perspective
may change your verification strategy.

**Codex routinely takes 2-3x longer than Claude.** Do not assume Codex is
dead, timed out, or stuck just because Claude finished first.

### During the wait

Trust the background-task notification; do not poll by default. If you
genuinely need a liveness check on a long run, launch the Claude reviewer with
`--monitor` (live phase and `STALLED!!` lines on stderr) or watch the codex
`[output_file:]` — a growing file or an advancing phase means it is working,
long-stale means investigate.

### Collect output

Each wrapper prints `[output_file: <path>]` on stderr and ends its reply with
`[session_id: <uuid>]`. The `[output_file:]` `.log` holds the clean reply plus
the `[session_id:]` line in every mode.

For each reviewer, read the **exact `[output_file:]` path** the wrapper printed
and extract its final analysis. Do **not** glob for the newest
`codex-agent-*.log` — the filenames carry no run stub, so "newest" can belong
to a different concurrent run. **Capture each reviewer's `[session_id:]`** for
the resume operations below. If a `[session_id:]` is absent, treat that
vendor's resume as unavailable and say so rather than guessing an id.

Check if either agent's output is only intermediate narration (tool-use
summaries like "Let me read...", "I'm checking...") without a final analysis.
This happens when agents spend their entire turn researching without
synthesizing. **Resume those agents** to get their conclusions:

- **claude**: `node "~/.claude/skills/claude-agent/scripts/claude-agent.mjs" --resume <session-id> "You were investigating <topic>. Synthesize your findings into a concrete analysis. What did you find? What's the root cause? What's the fix?"`
- **codex**: `node "~/.claude/skills/codex-agent/scripts/codex-agent.mjs" --resume <session-id> "You were investigating <topic>. Synthesize your findings into a concrete analysis. What did you find? What's the root cause? What's the fix?"`

Only proceed to verification once you have substantive analysis from both
agents (not just intermediate progress text).

## Skeptically verify their claims

For each claim or issue an agent raised, send a sub-agent to check it against
the actual code. Be skeptical — grep for the thing, read the file, think hard
about it and ask yourself if the claim holds up. Don't take the review agents
at their word.

Launch verification sub-agents in parallel where possible.

## Push back where claims don't hold up

For anything that looks like a false positive or a stretch, **resume** the
original agent's session and push back with evidence. Tell it what you found
and ask it to look again:

- **claude**: `node "~/.claude/skills/claude-agent/scripts/claude-agent.mjs" --resume <session-id> "pushback message"`
- **codex**: `node "~/.claude/skills/codex-agent/scripts/codex-agent.mjs" --resume <session-id> "pushback message"`

The agent should defend its position with new evidence or concede. If it
still disagrees after looking again, that's a live dispute.

## Settle disputes with the other agent

Any 2-way dispute — one agent says it's real, you (or a sub-agent) say it's
not, and the agent defended itself — put it to the **other** agent by
resuming that agent's session with the dispute context. The third perspective
settles it.

From TheSylvester/agentic-coding-tools, MIT.

More from TheSylvester/agentic-coding-tools