Blog

6 min read

Claude plans, GPT executes: my agentic workflow

One Claude session thinks, decides and reviews. Execution goes to GPT agents isolated in worktrees. This is the workflow I use across my projects, from request to cherry-pick.

  • agents
  • workflow
  • claude
  • gpt
  • pi

Asking an agent for code is easy. The hard part is knowing what landed on the branch once it's done. If the same model plans, implements and then tells you everything is fine, the review falls on me, and I start from scratch.

So in my workflow those roles are split. One Claude Opus 5.5 session, which I call the orchestrator, thinks, decides and reviews. Execution goes to pi agents, each one in its own worktree. Nothing reaches the working branch without going through the orchestrator's review and checks.

I use this workflow across my projects, not just one. The examples and diagrams in this post come from Ergit.

Who does what

There are four roles. The orchestrator is the session I talk to. The other three are pi agent profiles, all called through the same script, the run.sh from the delegate skill:

  • Fast Executor (GPT-6.1 Terra, thinking xhigh): implements well-specified tasks, answers lookups and makes mechanical edits. Every task starts here.
  • Deep Engineer (GPT-6.1 Sol, thinking high): bugs that need investigation, refactors across modules and whatever Terra couldn't close.
  • Reviewer (GPT-6 Astra, thinking medium): read-only. Checks the diff against the spec and returns a verdict with findings.

Next to them sit two tools: the Codex CLI, used only to generate images, and the JEV judge, which classifies and validates text or images.

Each profile sets the model, the thinking level and the tools. To change a role, I edit the profile, never run.sh.

I picked pi as the executor for speed and context cost. In the November 7 measurements, it reached the first token in about 2 s, against 4 to 17 s for codex exec, and sent 5 to 7 times fewer input tokens per task.

One thing matters here: with bash access, pi runs without a sandbox. Isolation comes from somewhere else. Each task runs in a separate worktree, in a clean environment without my shell's secrets, and everything goes through the orchestrator's review before it lands.

Why Claude plans and GPT executes

The two models work differently, and the workflow is built around that.

GPT models, in Codex or ChatGPT, follow instructions very well. They do what the spec asks, the way it asks. Claude is more proactive: when something is missing from the request, it notices and fills it in.

In planning, that proactivity helps. The gaps I leave when describing a task get filled by Claude, and the instructions it passes to the executors come out sharper. In execution, I want the opposite: a model that follows the spec to the letter. Put together, GPT gets a better spec and performs better, precisely because it sticks to what's written.

The life of a task

All work starts with a PBI card in Todoist. The orchestrator reads the context (the PRD, the RFC for that area and whatever is already recorded in Lambda Memory) and only then asks whether the design is approved. If it isn't, we discuss it first. Nothing is delegated without a design.

Once the design is approved, the orchestrator breaks the work down and writes the spec. run.sh new creates the worktree and the dlg/<name> branch and saves the spec. The agent implements, tests and commits. Then the orchestrator reads the whole diff, runs the checks and integrates with a cherry-pick onto the working branch, never straight to main.

One detail worth knowing: the worktree starts from HEAD. Uncommitted changes in the main repository don't come along.

Which command to use

The first question is always whether the work can be delegated at all. Design, domain rules, security, deploys, remote git and Todoist stay with the orchestrator. After that, you walk down the ladder: the first "yes" tells you the command.

In practice, almost everything fits in a handful of commands:

R=~/.claude/skills/delegate/run.sh
 
# read-only: never creates or deletes files
$R query -- "where is merge_lock acquired?"
 
# creates the worktree and the dlg/i18n-billing branch, saves the spec and implements
$R new i18n-billing -- "…"
 
# continues the same session, with the same agent
$R continue i18n-billing -- "…"
 
# Reviewer verdict and findings
$R review i18n-billing
 
# deletes the worktree after integrating
$R remove i18n-billing

When the agent gets stuck

Every task starts with the Fast Executor. If it returns UNSURE:, fails verification or stops halfway through a plan, the orchestrator tries one continue with a direct instruction. If it's still stuck, the task moves up to the Deep Engineer. The last resort is rewriting the spec or doing it by hand.

GPT models tend to stop after the first task of a plan and return the report. That's why the spec names every task and says all of them must be committed in the same run.

Several tasks at once

Independent tasks go out together: one run.sh new per task, each in the background and in its own worktree. The rule that saves headaches is splitting the work so each task touches different files. That way the cherry-picks land without conflicts.

The Reviewer doesn't replace the review

The Reviewer costs time, so it only runs where it pays off: diffs over 150 lines, more than four files, or touching a sensitive area. Auth, tokens, concurrency, billing, migrations and API contracts are on that list. In Ergit, so are the gate, scope, merge and push rules.

Even then, its findings are input, not decisions. Each one is checked in the code before it turns into action, and the orchestrator still reads the whole diff.

The spec is what matters most

Across 470 test runs, the prompt format (labels, XML or prose) didn't change the outcome. The spec does. Every delegation carries the same fields, written by the orchestrator:

Context: PBI-014 (i18n). Read the design first at
  docs/superpowers/specs/2026-10-22-pbi-014-i18n-design.md
Goal: move the hard-coded messages on the billing screen
  into the catalog, in EN and PT_BR.
Scope: platform/web/src/views/billing/,
  platform/web/src/i18n/{en,pt-BR}/billing.ts
Out of scope: other catalogs; billing logic.
Rules:
  - Glossary terms stay in English in pt-BR (merge, token, push).
  - Never call t() at module top level.
Acceptance criteria:
  - With pt-BR, the screen shows Portuguese with accents.
  - The completeness test passes: no missing or extra keys.
Verification: npm run typecheck && npm test
Commits: one commit, cite PBI-014.
Output format: changed files and test results,
  e.g. src/i18n/en/billing.ts:12
  If stuck: "UNSURE: <reason>"

A few lessons came out of those runs:

  • Give a literal example of the output. Without one, paths came back relative to the searched folder.
  • Don't leave behavior open. An unanswered question in the spec turns into a choice split down the middle.
  • Several steps? Say they all go in this run. Otherwise the model stops after the first one.
  • Long or sudo gates stay with the orchestrator. The agent is told not to run them.

Before calling it done

Everything that comes from the agent is treated as untrusted until checked. After each delivery, the orchestrator follows the same order:

  1. Reads errors and any UNSURE:.
  2. Checks every cited path:line and count with grep or sed -n.
  3. Reads the whole diff, looking for out-of-scope changes, disabled tests or shortcuts.
  4. Runs verification itself. The report's "passed" doesn't count.
  5. Fixes: small things it corrects directly; bigger ones get a continue.
  6. Integrates with a cherry-pick onto the working branch.
  7. Removes the worktree.
  8. Tells me what was delegated, to which agent, and what was verified.

What is never delegated

The agents are executors. Planning, instructions and reviews belong to the orchestrator. An agent can answer a one-off lookup the orchestrator uses, but it never drafts a design document.

Off-limits for delegation: anything without an approved design, specs and architecture decisions, domain rules (gate, scope, merge, push and auth), security decisions and secrets, deploys, servers, remote git and Todoist. And the simplest case of all: when explaining the task costs more than doing it, the orchestrator just does it.

How much of the limits this uses

My weekly subscription limits last the whole week. Running at least five projects at the same time, I get close to the reset with 20% to 30% left: on average, I use about 80% of my Claude limit and 70% of my Codex limit.

Close to Google's Elephant-Goldfish

In October, Google released the Elephant-Goldfish Model (announcement), a plugin for coding agents that splits work between two kinds of session. The elephant holds the project context and drafts the spec, without writing code. The goldfish start with no memory of the conversation and get only the document and the files it references, so they can review the proposal without inheriting the author's blind spots. Architecture decisions stay with the human.

My workflow is very close to that, and it's good to know it isn't far from what leading companies are doing. The orchestrator plays the elephant: it holds the context, talks to me and writes the spec. The executors and the Reviewer play the goldfish: they get the spec and the code, never the conversation.

The difference is where the clean context comes in. In Google's model, the goldfish review the design before any code exists. In mine, they implement and review the diff, and the design goes through me before anything is delegated.