Cline rules

1---
2description: Guides Cline on how to spawn and manage Claude Code subagents
3author: https://github.com/nickbaumann98
4version: 1.0
5category: "Cline Core"
6tags: ["subagents", "claude code", "multi-agent"]
7globs: ["*"]
8---
9# Claude Code Subagent Rules
10 
11## Basic Spawning
12```bash
13# Simple execution
14claude -p "Your prompt here"
15 
16# With JSON output for parsing
17claude -p "Build feature" --output-format json
18 
19# With streaming for long tasks
20claude -p "Complex task" --output-format stream-json --verbose
21```
22 
23## Session Management
24```bash
25# Capture session ID
26SESSION_ID=$(claude -p "Start task" --output-format json | jq -r '.session_id')
27 
28# Continue session
29claude -p --resume "$SESSION_ID" "Next step"
30 
31# Continue most recent
32claude -p --continue "Add more features"
33```
34 
35## Essential Options
36```bash
37# Limit turns to control cost
38claude -p "Task" --max-turns 3
39 
40# Custom system prompt
41claude -p "Task" --system-prompt "You are an expert in X"
42 
43# Allow/disallow specific tools
44claude -p "Task" --allowedTools "Read,Write,Bash"
45claude -p "Task" --disallowedTools "Bash(rm)"
46 
47# Permission modes for autonomous operation
48claude -p "Task" --permission-mode acceptEdits    # Auto-accept file edits
49claude -p "Task" --permission-mode bypassPermissions  # Skip all permission prompts
50claude -p "Task" --permission-mode plan          # Plan mode only
51```
52## Autonomous Subagents
53```bash
54# Fully autonomous - bypasses ALL permission prompts
55claude -p "Build complete app" --permission-mode bypassPermissions --max-turns 10
56 
57# Auto-accept edits but prompt for dangerous operations
58claude -p "Refactor codebase" --permission-mode acceptEdits --max-turns 5
59 
60# Combine with tool restrictions for safety
61claude -p "Safe autonomous task" \
62  --permission-mode bypassPermissions \
63  --disallowedTools "Bash(rm),Bash(git push)" \
64  --max-turns 3
65```
66 
67## Monitoring & Error Handling
68```bash
69# Check success and extract data
70if RESULT=$(claude -p "$prompt" --output-format json); then
71    COST=$(echo "$RESULT" | jq -r '.total_cost_usd')
72    echo "Success! Cost: $COST USD"
73else
74    echo "Failed with exit code $?"
75fi
76 
77# Timeout for long tasks
78timeout 300 claude -p "$prompt" || echo "Timed out"
79```
80 
81## Advanced Pattern: Parallel Agentic Workflows
82 
83This pattern, inspired by "Midjourney for Code," involves spawning multiple agents in isolated environments to generate diverse solutions to a single problem. This is useful for prototyping, A/B testing features, or exploring different implementations.
84 
85### Core Principle: Keep It Simple
86 
87The claude CLI is already well-designed for autonomous operation. Don't over-engineer with complex monitoring or JSON parsing unless you specifically need it.
88 
89### Pattern 1: Simple Parallel Variations
90 
91The most effective pattern for generating multiple variations:
92 
93```bash
94#!/bin/bash
95# spawn_variations.sh - Dead simple parallel execution
96 
97# Define your variations
98for i in {1..5}; do
99  mkdir -p "variant-$i"
100  (
101    cd "variant-$i" && \
102    claude -p "Build [YOUR TASK] - Variation $i: [specific approach/style]" \
103      --permission-mode bypassPermissions \
104      --max-turns 15
105  ) &
106done
107
108wait
109echo "✅ All variations complete. Check variant-*/ directories"
110```
111 
112That's it. The claude CLI handles progress display, error reporting, and retries automatically.
113 
114### Pattern 2: Parallel Features on Existing Codebase
115 
116For working on an existing project with git:
117 
118```bash
119#!/bin/bash
120# spawn_features.sh - Parallel feature development
121 
122FEATURE="implement dark mode"
123BASE_BRANCH=$(git branch --show-current)
124
125for approach in "css-variables" "theme-provider" "tailwind-classes"; do
126  git checkout -b "feature-$approach" "$BASE_BRANCH"
127  
128  (
129    claude -p "Add $FEATURE using $approach approach" \
130      --permission-mode bypassPermissions \
131      --max-turns 20
132  ) &
133done
134
135wait
136echo "✅ Features ready on branches: feature-*"
137```
138 
139### Pattern 3: Quick A/B Testing
140 
141For comparing different implementations:
142 
143```bash
144#!/bin/bash
145# ab_test.sh - Compare two approaches
146
147mkdir -p option-a option-b
148 
149# Option A
150(cd option-a && claude -p "Build a todo app using vanilla JavaScript" --permission-mode bypassPermissions) &
151 
152# Option B  
153(cd option-b && claude -p "Build a todo app using React" --permission-mode bypassPermissions) &
154
155wait
156echo "✅ Both options ready for comparison"
157```
158 
159### When to Add Complexity
160 
161Only add monitoring/logging when you need:
162- **Automated selection** - Parsing results to pick best variant
163- **CI/CD integration** - Running in non-interactive environments  
164- **Cost tracking** - Analyzing spend across many runs
165- **Bulk operations** - Managing 10+ parallel agents
166 
167For interactive development, the simple patterns above are optimal.
168 
169### Monitoring (When Needed)
170 
171If you need to monitor progress:
172 
173```bash
174# In another terminal
175watch -n 2 'find . -name "*.html" -o -name "*.js" | wc -l'
176 
177# Or check completion
178ls -d variant-*/index.html 2>/dev/null | wc -l
179```
180 
181### Cost Awareness
182 
183```bash
184# Set turn limits based on task complexity
185SIMPLE_TASK_TURNS=5
186MEDIUM_TASK_TURNS=10  
187COMPLEX_TASK_TURNS=20
188
189claude -p "Simple task" --max-turns $SIMPLE_TASK_TURNS
190```
191 
192## Key Tips
193- **Keep it simple** - Basic bash patterns work best
194- **Trust the tool** - Claude CLI already handles errors, retries, and progress
195- **Set `--max-turns`** to control costs
196- **Use `--permission-mode bypassPermissions`** for fully autonomous operation
197- **Don't capture output you won't use** - Let the CLI display progress naturally
198