delegate-to-claude-code

name

delegate-to-claude-code

description

Delegate unusually complex planning, architecture, debugging, or multi-file coding work to Claude Code using the preferred Fable/Claude Fable 5 model at high effort, while Codex remains the orchestrator. Use when the user explicitly invokes this skill or asks for Claude Code/Fable on a hard build, creative coding artifact, large refactor, difficult bug, architecture decision, security/performance-sensitive change, or independent senior-model pass. For explicit build/code requests, Claude Code should usually implement the main artifact, not just advise; do not use for simple edits, routine file reads, small command answers, or tasks where delegating private/secrets-heavy context would be unsafe.

Delegate To Claude Code

Overview

Use Claude Code as a high-effort specialist for the hardest part of the task, not as a replacement for Codex judgment. For hard build/code requests, the "hardest part" is usually the implementation itself. Codex must still gather context, set success criteria, monitor progress, review the diff, run verification, fix defects, and own the final answer.

Do not include gimmick prompt text such as tips, flattery, or demands for hidden chain-of-thought. Ask Claude to think carefully and return concise rationale, plans, diffs, risks, and verification steps.

Delegation Decision

Use this skill when at least one is true:

• The user explicitly invokes this skill for a build, coding, or implementation task.
• The task needs architecture, strategy, or multi-step planning before implementation.
• The task involves a large or cross-cutting code change where another senior-model pass could catch design mistakes.
• The task is a creative coding artifact where taste, interaction design, camera/control feel, or visual polish matters.
• A bug is hard to isolate and needs hypothesis generation, trace planning, or deep code reading.
• The implementation has high blast radius: migrations, auth, payments, security, data loss, performance, concurrency, or public API behavior.
• The user explicitly asks to use Claude Code, Fable, Fable 5, Claude Fable 5, or an external model for the hard part.

Do not delegate when the task is straightforward, when local context is enough, when the request is mainly file lookup or summarization, or when the required context contains secrets that should not be passed to another process.

Delegation Mode

Default to implementation delegation for explicit build/code requests. Do not downgrade to advisory-only just because the workspace is dirty; instead choose a safe write scope:

• If the work is a new standalone artifact, tell Claude Code to create that exact file path and use --permission-mode acceptEdits.
• If existing files must change and the worktree has unrelated edits, isolate the work in a branch/worktree when feasible, or constrain Claude to a named disjoint file set.
• If writes are unsafe because secrets, production data, or unclear ownership are involved, use plan mode and explain the blocker.
• If the user asks only for strategy, review, or options, use plan mode.

When Claude is implementing, the prompt must say: create or edit the requested files now; do not stop at a plan; do not ask whether to proceed unless blocked by a real permission or safety issue. If Claude pauses at a "ready to code" approval screen, resume/restart it in edit mode or continue locally only after noting that the delegation failed.

Workflow

1. Read enough local context yourself first: user request, repo state, relevant files, current diff, tests, and constraints.
2. Create a compact prompt packet for Claude:
   • exact user goal and success criteria
   • repo path and relevant file paths
   • summaries or excerpts of relevant code
   • current constraints from the user/system
   • what Claude should decide or implement
   • expected output shape: plan, patch, risks, tests, or status
3. Prefer --model fable --effort high. If the local CLI rejects fable, try --model claude-fable-5; if neither works, report the model blocker and either use the configured Claude default or continue locally.
4. Choose execution mode:
   • Build/code/artifact requested: use --permission-mode acceptEdits with a tight write scope.
   • Advisory, review, or strategy only: use --permission-mode plan.
   • Risky or conflicting workspace: create an isolated branch/worktree first, or constrain Claude to new/disjoint files.
5. Start Claude Code with the helper script or a direct CLI command.
6. Check progress periodically. If Claude stalls, fails, or makes unclear changes, ask it for a concise status or stop using the output.
7. Integrate only after independent review:
   • inspect any diff Claude produced
   • verify it obeys the user's latest instructions
   • run focused tests, type checks, linters, or manual validation
   • fix issues yourself when needed
8. In the final response, state what was delegated only when it matters for transparency. Do not present Claude's output as verified until you have verified it.

Helper Scripts

Use scripts/start_delegation.py to start a background Claude Code task from a prompt file:

python3 /Users/skirano/.codex/skills/delegate-to-claude-code/scripts/start_delegation.py /tmp/claude-prompt.md --cwd "$PWD" --name "hard-refactor-plan" --mode plan

For the normal hard-build implementation path:

python3 /Users/skirano/.codex/skills/delegate-to-claude-code/scripts/start_delegation.py /tmp/claude-prompt.md --cwd "$PWD" --name "hard-refactor-impl" --mode acceptEdits

Use scripts/check_delegations.py to inspect background progress:

python3 /Users/skirano/.codex/skills/delegate-to-claude-code/scripts/check_delegations.py --cwd "$PWD" --all

The direct fallback commands are:

claude --bg --model fable --effort high --permission-mode acceptEdits --name "hard-build" "$(cat /tmp/claude-prompt.md)"
claude --bg --model fable --effort high --permission-mode plan --name "hard-task" "$(cat /tmp/claude-prompt.md)"
claude agents --json --cwd "$PWD" --all

To ask an existing session for status, use the session id reported by claude agents --json:

claude --resume <session-id> -p --model fable --effort high --permission-mode plan "Give a concise status: completed work, blockers, files changed, and next action. Do not edit files."

Prompt Packet Template

You are Claude Code running as a high-effort specialist. Think carefully and provide a concise, verifiable answer.

Task:
<exact user goal>

Workspace:
<absolute repo path>

Relevant context:
- <file path>: <why it matters>
- <current diff or important excerpts>

Constraints:
- Follow the user's latest instructions.
- Do not ignore existing uncommitted changes.
- Do not use secrets or credentials.
- Return concise rationale, concrete steps, risks, and verification.

Requested output:
<implementation edits / plan only / debugging hypotheses / code review / test plan>

For build/code requests, use this stronger requested output:

Requested output:
- Implement the requested artifact/change directly in the workspace.
- Keep writes limited to these paths: <paths>.
- Do not stop after a plan or ask whether to proceed unless there is a real blocker.
- When finished, report files changed, key decisions, risks, and verification commands to run.

Verification Rules

Treat Claude Code output as untrusted until checked. Never blindly forward it to the user or leave its edits unreviewed.

For code work, run at least one focused verification command when feasible. If verification cannot run, say why. If Claude edited files, inspect git diff before continuing and make any needed corrections with normal Codex tools.