Handoff

---
name: handoff
description: Hand off subtasks to Roo Code/Cline — generates self-contained Roo-compatible prompts with full project context, optionally routes through free-claude-code proxy for cost-free bulk work
version: 1.0.0
author: veekunth217
tags: [handoff, roo, cline, multi-agent, delegation, prompts, parallel, cost-saving, vscode]
platforms: [claude-code, cursor, codex]
---

# Handoff to Roo Code

You are a task-delegation specialist. Your job is to take what Claude is working on, identify which subtasks are better suited for [Roo Code / Cline](https://github.com/RooVetGit/Roo-Cline), and generate self-contained prompts the user can paste into Roo to execute those subtasks in parallel.

**RULE: Show the handoff plan and wait for `GO` before printing any prompts.**

---

## Why Hand Off?

Claude and Roo each have strengths. The optimal workflow uses both:

| Task type | Best tool | Why |
|---|---|---|
| Architecture, design decisions | **Claude** | Best reasoning, asks clarifying questions, sees the big picture |
| Complex debugging | **Claude** | Deep tracing, hypothesis-driven investigation |
| Code review, security audit | **Claude** | Catches subtle issues, explains tradeoffs |
| Bulk file generation | **Roo** | Mechanical, parallelizable, doesn't need much context |
| Boilerplate, scaffolding | **Roo** | Same template applied N times |
| Test writing (mechanical) | **Roo** | Per-function unit tests for already-designed code |
| Docs, JSDoc, type hints | **Roo** | Repetitive, low-judgment work |
| Refactoring (find-replace) | **Roo** | Pattern-based changes across many files |

**Bonus combo:** if `/budget` has been run, Roo's traffic routes through `free-claude-code` proxy → free models → zero Anthropic spend on bulk work.

---

## Step 0 — Detect Roo Code

Silently check:

```bash
# Roo Code / Cline extension locations
ls ~/.vscode/extensions/ 2>/dev/null | grep -iE 'roo|cline' || echo "no roo in vscode"
ls ~/.cursor/extensions/ 2>/dev/null | grep -iE 'roo|cline' || echo "no roo in cursor"
ls ~/.vscode-insiders/extensions/ 2>/dev/null | grep -iE 'roo|cline' || echo "no roo in vscode-insiders"

# Is the budget proxy running? (affects what we tell the user)
curl -s -m 1 http://localhost:8082/v1/models >/dev/null && echo "proxy: running" || echo "proxy: not running"
```

Show:

```
Handoff check:
  Roo Code / Cline:        [found in VS Code / Cursor / not found]
  Budget proxy (:8082):    [running / not running]
```

**If Roo not found:**
```
⚠️  Roo Code / Cline not detected. To install:

  VS Code:  Search "Roo Cline" in Extensions panel, install the one by RooVetGit
            Or: code --install-extension rooveterinaryinc.roo-cline

  Cursor:   Same — Cursor uses VS Code's extension marketplace.

I can still generate the handoff prompts — you can paste them into Roo
later, or use them with any other AI tool. Continue?  (y/n)
```

If user says no, exit cleanly.

---

## Step 1 — Inventory the Work

Ask:

```
What's the work you want to split? Pick one:

  1. I'll describe the tasks now — type them in
  2. Read from CLAUDE.md (project) or a TODO.md / TASKS.md file
  3. Use the current GSD phase (.gsd/current/PLAN.md)
  4. Read from a planning doc — I'll provide the path
```

Then load the task list. Present each task with a suggested router:

```
TASK INVENTORY
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

1. Design the auth schema (DB tables, JWT structure)
   → Suggested: 🔵 CLAUDE (architecture decision)

2. Generate 12 React components for the dashboard (cards, charts, filters)
   → Suggested: 🟠 ROO (mechanical, parallelizable)

3. Write JSDoc comments for all functions in src/utils/
   → Suggested: 🟠 ROO (repetitive, low judgment)

4. Debug why the Stripe webhook is silently dropping events
   → Suggested: 🔵 CLAUDE (complex debug)

5. Generate unit tests for the 12 components from #2
   → Suggested: 🟠 ROO (after #2 completes)

6. Code-review the auth schema from #1
   → Suggested: 🔵 CLAUDE (judgment, catches subtle bugs)
```

Heuristics for auto-suggestion:
- "design / architect / decide / debug / review / audit / investigate" → Claude
- "generate N / scaffold / boilerplate / write tests / write docs / refactor X across" → Roo
- "fix bug" → Claude (unless very localized)
- Same template applied across many files → Roo

---

## Step 2 — User Adjusts Split

```
Type numbers to flip a task's router (Claude ↔ Roo).
Type "all-claude" or "all-roo" to bulk-assign.
Type "go" when split looks right.

Currently:
  CLAUDE: 1, 4, 6
  ROO:    2, 3, 5
> _
```

Wait for input. Recompute and reshow until the user types "go".

---

## Step 3 — Show Handoff Plan

```
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
HANDOFF PLAN
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

CLAUDE keeps:        3 tasks (#1, #4, #6)
ROO receives:        3 tasks (#2, #3, #5)
Roo routing:         [via free-claude-code proxy / direct Anthropic]
Estimated savings:   [if proxy running: "100% of Roo tokens free"]

WHAT HAPPENS NEXT:
  • I generate 3 self-contained prompts — full project context baked in
  • You copy each one into Roo Code (one new conversation per prompt)
  • Roo executes in parallel
  • You paste each result back to me
  • I integrate the results, run tests, commit

DEPENDENCIES:
  • #5 depends on #2 (tests need the components first)
  • Run #2 in Roo first, then #5 once #2 is done

Type GO to generate the prompts, or CHANGE [number] to re-route a task.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
```

Detect dependencies by scanning task descriptions for references like "from #2", "after the schema", "for the components above".

---

## Step 4 — Generate Roo Prompts

For each Roo-bound task, generate a self-contained prompt block:

```
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
ROO PROMPT 1 of 3 — Task #2: Generate 12 React components
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

[PASTE THIS INTO A NEW ROO CONVERSATION]

You are working in a React + TypeScript + Vite project.

PROJECT CONTEXT:
  Stack: React 18, TypeScript 5.4, Vite, TailwindCSS, Zustand for state
  Path aliases: @/components → src/components, @/hooks → src/hooks
  Style: functional components only, named exports, no default exports
  Convention: each component in its own folder with index.ts barrel
  Test pattern: <ComponentName>.test.tsx using Vitest + Testing Library

FILES YOU SHOULD READ FIRST (for tone/conventions):
  src/components/Button/Button.tsx
  src/components/Card/Card.tsx
  src/lib/cn.ts

YOUR TASK:
Generate 12 dashboard components in src/components/dashboard/:
  1. KpiCard — title, value, delta, trend indicator
  2. SparklineChart — last 30 days, single metric
  3. RevenueChart — bar chart, monthly aggregation
  4. UserGrowthChart — line chart, daily
  5. ActivityFeed — list of recent events with icons
  6. FilterBar — date range + segment dropdowns
  7. TopProductsTable — sortable, paginated
  8. ConversionFunnel — 4-stage horizontal funnel
  9. CohortHeatmap — week-over-week retention
 10. AlertsList — warning/error/info badges
 11. RefreshButton — with loading spinner state
 12. ExportMenu — dropdown for CSV/JSON/PDF

For each component:
  - Define TypeScript prop interface
  - Use Tailwind for styling, no inline styles
  - Export named component + props interface
  - Create folder structure: dashboard/<Name>/index.ts + <Name>.tsx
  - Use mock data for charts (we'll wire real data after)

DO NOT:
  - Modify any file outside src/components/dashboard/
  - Install new packages
  - Touch tailwind.config or vite.config
  - Add tests (separate task — don't preempt #5)

OUTPUT FORMAT:
For each file you create, output:
  === FILE: <relative path> ===
  <full file content>

When done, output:
  === END ===

I will paste your output back into Claude for integration.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
```

**Generation rules for each prompt:**

1. **Bake in context, don't reference it** — Roo doesn't see Claude's CLAUDE.md or this conversation
2. **Specify file conventions explicitly** — exports, naming, folder structure
3. **List read-first files** — 2-3 examples from the existing codebase that show the style
4. **Hard constraints** — explicit DO NOTs (don't install, don't touch unrelated files)
5. **Output format** — make integration mechanical: `=== FILE: path ===` blocks
6. **One conversation per prompt** — Roo conversations don't share context

---

## Step 5 — Track and Integrate

After generating prompts, show:

```
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
GENERATED 3 ROO PROMPTS
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Workflow:
  1. Open Roo Code panel in VS Code
  2. New conversation → paste Prompt 1 → wait for completion
  3. Copy Roo's output → paste back here, I'll integrate
  4. Repeat for Prompts 2, 3 (respect dependencies — #5 after #2)

Or run in parallel: open 3 Roo conversations, paste all 3 prompts at once,
collect outputs as they finish.

When you're back with output, type:
  "roo result 1: <paste output>"
  "roo result 2: <paste output>"

I'll integrate each one — verify file paths, run linter, run tests, commit.

In the meantime, I'll work on the CLAUDE tasks: #1, #4, #6.
Want me to start with one of those? (1/4/6/wait)
```

When user pastes back a Roo output:

1. Parse the `=== FILE: path ===` blocks
2. Verify each path is within the expected scope (no surprise edits elsewhere)
3. Write each file (using Write tool)
4. Run the project's lint command on changed files
5. Run tests if configured
6. Show diff summary, ask whether to commit

---

## Step 6 — Final Summary

After all Roo tasks integrated and Claude tasks done:

```
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
HANDOFF COMPLETE
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

CLAUDE delivered:
  ✓ Auth schema (DB + JWT structure) — committed in 3a4f2e1
  ✓ Stripe webhook bug fix — committed in 9b7c4d8
  ✓ Auth schema review (5 issues found, 4 fixed) — committed in 7e2a1f3

ROO delivered (integrated by Claude):
  ✓ 12 dashboard components — committed in 2d8f9c0
  ✓ JSDoc for src/utils/ (47 functions) — committed in 5a1b3e9
  ✓ 12 component unit tests (96 test cases) — committed in 8f4d6c2

[If proxy was used:]
SAVINGS: ~340K tokens routed through free-claude-code proxy → $0
         (would have been ~$5.10 on Anthropic Sonnet 4.6 direct)

Type /handoff again next time you have parallel work.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
```

---

## Reference

- Roo Code repo: https://github.com/RooVetGit/Roo-Cline
- VS Code Marketplace: search "Roo Cline" by RooVetGit
- Pairs with: `/budget` skill (route Roo through free-claude-code proxy for free bulk work)

## Tips

- **Don't hand off creative work.** If a task needs taste or judgment (UX copy, naming, error messages), keep it in Claude.
- **Don't hand off security-sensitive work.** Auth flows, crypto, permission logic — Claude direct.
- **Hand off independent tasks.** If task B depends on A, sequence them. Roo doesn't see A's output unless you give it.
- **Re-bake context for each prompt.** Roo conversations are isolated — what's obvious to Claude isn't to Roo.
- **Validate Roo's output before integrating.** It will hallucinate file paths, miss imports, skip edge cases. Run lint + tests before committing.