Arbitrage
Fable tokens are expensive; the user's codex quota sits unused. Exploit the price gap: spend Fable tokens on judgment — planning, specs, design intent, visual validation — and spend codex quota on all code-writing volume.
You ARE the Fable session. "Here" means you do it yourself. There is no separate Fable to delegate to.
Routing Table
| Work |
Where |
Why |
| Planning, specs, architecture decisions |
Here |
Judgment is what Fable is paid for |
| ALL implementation — backend, frontend, anything that writes code |
codex via /goal |
Quota is free; typing code is not where Fable adds value |
| Visual validation of UI work (run the app, screenshot, judge, iterate) |
Here |
Fable's design eye is worth the price — validate, don't type |
| Investigation and debugging analysis (root-causing hard bugs) |
Here |
Judgment work; the resulting fix dispatches with a precise spec |
| Diff review, commits, pushes, PRs |
Here |
Git operations stay under your control |
| Trivial edits riding along with review/validation (one-liners, any layer) |
Here |
Dispatch overhead exceeds the work |
| Work codex has demonstrably struggled with |
Here |
Escape hatch — see below |
Dispatch Protocol
- Spec first. Write a spec file in the worktree: objective, constraints, files/areas involved, acceptance criteria — the exact test command that must go green — and what NOT to touch. For frontend work the spec carries the design intent: layout, states, interactions, spacing, motion, reference patterns. For the hardest parts, spec down to pseudocode — the thinking stays here; the typing still dispatches.
- Dispatch in the background and keep working:
codex exec --cd <worktree> "/goal <one-line objective; details in SPEC.md>"
codex runs gpt-5.5 with xhigh reasoning (its default config); it implements and gets tests green in the isolated worktree while you continue planning/spec/validation work in parallel.
- Review the diff here. Commit, push, and open PRs from this session.
Visual Validation Loop (frontend)
- codex implements the UI per spec.
- Run the app here — interact, screenshot, judge against the design intent.
- Write concrete visual feedback (what's off, by how much, what good looks like) and re-dispatch.
- Loop until it looks right; then diff review + git here.
Escape Hatch: When codex Struggles
Struggle must be observed, not predicted. Always dispatch first — predicting "codex can't do this" just means the spec needs pseudocode-level detail. But two strikes and it's yours: if a re-dispatch with concrete corrective feedback still comes back missing the acceptance criteria or mangling the approach, stop re-dispatching and write the code here yourself, salvaging whatever of codex's diff is sound.
Red Flags
| Thought |
Reality |
| "Frontend is design-critical, so I'll code it here" |
Fable's taste shows up in the spec and the validation loop, not in typing JSX. Dispatch it. |
| "Faster to just write it myself" |
Premium tokens on rote work. Spec it, dispatch it, validate in parallel. |
| "This part is too hard for codex" |
Predicted struggle is not observed struggle. Spec it at pseudocode level and dispatch; you only take over after two failed rounds. |
| "I'll let codex commit and push" |
Review the diff and run git from this session. |
| "No time to write a spec" |
An unspecced dispatch comes back wrong and costs more Fable tokens to fix than the spec would have. |
Common Mistakes
- Dispatching without acceptance criteria → codex returns "done" with red tests. Always name the test command that must pass.
- Dispatching frontend work without design intent in the spec → generic UI comes back; the validation loop burns rounds recovering what the spec should have said.
- Blocking on codex → run it in the background; keep doing planning/spec/validation work in parallel.
- Splitting one coherent unit across dispatches → pick one owner per unit; split at the API boundary, not mid-feature.
1---2name: arbitrage3description: Always active when coding in a Claude (Fable) session. Triggers whenever implementation work is being planned, scoped, or about to start — before writing any code — to decide where each piece of work executes.4---56# Arbitrage78Fable tokens are expensive; the user's codex quota sits unused. Exploit the price gap: spend Fable tokens on judgment — planning, specs, design intent, visual validation — and spend codex quota on all code-writing volume.910**You ARE the Fable session.** "Here" means you do it yourself. There is no separate Fable to delegate to.1112## Routing Table1314| Work | Where | Why |15|------|-------|-----|16| Planning, specs, architecture decisions | Here | Judgment is what Fable is paid for |17| **ALL implementation — backend, frontend, anything that writes code** | codex via `/goal` | Quota is free; typing code is not where Fable adds value |18| Visual validation of UI work (run the app, screenshot, judge, iterate) | Here | Fable's design eye is worth the price — validate, don't type |19| Investigation and debugging analysis (root-causing hard bugs) | Here | Judgment work; the resulting fix dispatches with a precise spec |20| Diff review, commits, pushes, PRs | Here | Git operations stay under your control |21| Trivial edits riding along with review/validation (one-liners, any layer) | Here | Dispatch overhead exceeds the work |22| Work codex has demonstrably struggled with | Here | Escape hatch — see below |2324## Dispatch Protocol25261. **Spec first.** Write a spec file in the worktree: objective, constraints, files/areas involved, acceptance criteria — the exact test command that must go green — and what NOT to touch. For frontend work the spec carries the design intent: layout, states, interactions, spacing, motion, reference patterns. For the hardest parts, spec down to pseudocode — the thinking stays here; the typing still dispatches.272. **Dispatch in the background and keep working:**28 ```bash29 codex exec --cd <worktree> "/goal <one-line objective; details in SPEC.md>"30 ```31 codex runs gpt-5.5 with xhigh reasoning (its default config); it implements and gets tests green in the isolated worktree while you continue planning/spec/validation work in parallel.323. **Review the diff here.** Commit, push, and open PRs from this session.3334## Visual Validation Loop (frontend)35361. codex implements the UI per spec.372. Run the app here — interact, screenshot, judge against the design intent.383. Write concrete visual feedback (what's off, by how much, what good looks like) and re-dispatch.394. Loop until it looks right; then diff review + git here.4041## Escape Hatch: When codex Struggles4243Struggle must be **observed, not predicted**. Always dispatch first — predicting "codex can't do this" just means the spec needs pseudocode-level detail. But two strikes and it's yours: if a re-dispatch with concrete corrective feedback still comes back missing the acceptance criteria or mangling the approach, stop re-dispatching and write the code here yourself, salvaging whatever of codex's diff is sound.4445## Red Flags4647| Thought | Reality |48|---------|---------|49| "Frontend is design-critical, so I'll code it here" | Fable's taste shows up in the spec and the validation loop, not in typing JSX. Dispatch it. |50| "Faster to just write it myself" | Premium tokens on rote work. Spec it, dispatch it, validate in parallel. |51| "This part is too hard for codex" | Predicted struggle is not observed struggle. Spec it at pseudocode level and dispatch; you only take over after two failed rounds. |52| "I'll let codex commit and push" | Review the diff and run git from this session. |53| "No time to write a spec" | An unspecced dispatch comes back wrong and costs more Fable tokens to fix than the spec would have. |5455## Common Mistakes5657- Dispatching without acceptance criteria → codex returns "done" with red tests. Always name the test command that must pass.58- Dispatching frontend work without design intent in the spec → generic UI comes back; the validation loop burns rounds recovering what the spec should have said.59- Blocking on codex → run it in the background; keep doing planning/spec/validation work in parallel.60- Splitting one coherent unit across dispatches → pick one owner per unit; split at the API boundary, not mid-feature.
blader