$claude

---
name: claude
description: Delegate a clearly bounded subtask from Codex to Claude Code. Use when the user explicitly asks for $claude or asks Codex to use Claude, and proactively consider it for UI, visual design, design variants, polish, UX copy, interaction details, layout, taste-heavy frontend work, and other bounded tasks where Claude is likely to produce a better specialist pass. If Claude's suitability is ambiguous, ask the user before delegating.
---

# Claude

Use Claude as a delegation primitive, not as the owner of the whole feature. Codex remains responsible for task framing, boundaries, review, integration, verification, and final reporting.

## Routing

Use Claude by default when the task is clearly about new visual design, UI composition, design variants, visual polish, UX copy, interaction states, layout, or taste-heavy frontend work.

Do the work directly in Codex when the task is clearly backend logic, API contracts, data modeling, migrations, auth/security behavior, infrastructure, small mechanical edits, or routine frontend wiring.

Ask the user before delegating when the task mixes design and engineering in a way where Claude's role is not crystal clear. Use a short question such as: "This has a design/taste component. Do you want me to delegate that pass to Claude?"

## Delegation Workflow

1. Inspect enough local context to scope the subtask accurately.
2. Check the working tree before invoking Claude so Claude's changes can be distinguished from existing work.
3. Write a bounded Claude prompt. Include role, task, context, authority boundaries, and expected output.
4. Run Claude through `scripts/run-claude-task.sh` with a prompt file, or call `claude -p` directly if the wrapper is not suitable.
5. Inspect Claude's diff before continuing.
6. Remove overreach, adapt the result to the repo's architecture, and handle integration work in Codex.
7. Run relevant checks when feasible.
8. Report what Claude did, what Codex changed afterward, and anything left unverified.

## Prompt Contract

Every Claude prompt must include this shape:

```text
Role:
You are Claude, acting as a specialist for this bounded subtask.

Task:
<one clear task>

Context:
<relevant files, repo conventions, current goal>

Boundaries:
- Only change files needed for this subtask.
- Preserve existing architecture, routing, components, tokens, and style conventions.
- Do not change backend behavior, schemas, auth, persistence, API contracts, infrastructure, or package dependencies unless explicitly authorized.
- Prefer the smallest clean change that accomplishes the task.
- Keep changes easy for Codex to review.

Output:
- Make the changes if edits are appropriate.
- Summarize changed files.
- Explain notable design or implementation decisions.
- Note anything Codex still needs to wire, verify, or decide.
```

For UI, design, variant, polish, or UX copy work, add:

```text
Design expectations:
- Improve visual hierarchy, spacing, alignment, responsive behavior, and interaction states.
- Preserve product intent and the existing design language.
- Include empty, loading, disabled, and error states when relevant to the changed surface.
- Avoid decorative overwork and avoid introducing a new design system unless the repo already needs it.
```

## Running Claude

Prefer the bundled wrapper when passing a substantial prompt:

```bash
scripts/run-claude-task.sh /path/to/prompt.txt
```

The wrapper uses `claude -p` with conservative defaults. If the wrapper is too restrictive for the task, call `claude -p` directly and keep the same delegation contract.

## Post-Claude Review

After Claude returns, Codex must inspect the actual changes before trusting them:

```bash
git diff --stat
git diff
```

Treat Claude's output as a strong first pass, not as final authority. Remove unrelated changes, tighten code, align naming and placement with the repo, and do the backend/data wiring yourself unless the user explicitly delegated that to Claude too.