octopus-quick

# Quick Mode - Lightweight Task Execution ⚡

Fast-track execution for small tasks that don't need full Double Diamond workflow overhead.

## When to Use Quick Mode

### ✅ Use Quick Mode For:

**Bug Fixes:**
- One-file bug fixes with known solution
- Typo corrections
- Logic error fixes
- Import/export corrections

**Configuration Changes:**
- Update environment variables
- Modify config files
- Adjust settings
- Update dependencies

**Small Refactorings:**
- Rename variables/functions
- Extract helper functions
- Simplify logic in single file
- Code cleanup

**Documentation:**
- Fix typos in README
- Update comments
- Add/update docstrings
- Clarify documentation

**Dependency Management:**
- Update package versions
- Add new dependency
- Remove unused dependency

### ❌ Don't Use Quick Mode For:

**Complex Work:**
- New features
- Architecture changes
- Multi-file refactorings
- Security-sensitive changes
- Performance optimizations requiring research
- Database schema changes
- API contract changes

**Use full workflows for complex work to ensure quality.**

---

## Execution Flow

Quick mode follows a streamlined process:

```
User Request → Direct Implementation → Atomic Commit → Summary
```

**What Quick Mode SKIPS:**
- ❌ Multi-AI research (probe/discover)
- ❌ Requirements planning (grasp/define)
- ❌ Multi-AI validation (ink/deliver)
- ❌ Plan-checker verification

**What Quick Mode KEEPS:**
- ✅ State tracking (records in state.json)
- ✅ Atomic commits (git commit with description)
- ✅ Summary generation (stored in .claude-octopus/quick/)
- ✅ Change documentation

---

## Usage

### Via Command

```bash
/octo:quick "add dark mode toggle to settings"
```

### Via Skill Invocation

```bash
Use skill: octopus-quick
Task: "fix typo in README.md line 42"
```

### Examples

```
/octo:quick "update Next.js to v15"
/octo:quick "fix the broken import in auth.ts"
/octo:quick "add error handling to login function"
/octo:quick "remove console.log statements"
```

---

## Implementation

### Step 1: Understand the Task

Quickly assess:
- What file(s) need to change?
- What's the specific change?
- Any dependencies or side effects?

### Step 2: Make the Change

Implement directly using appropriate tools:
- **Edit** - For modifying existing files
- **Write** - For creating new files (rare in quick mode)
- **Bash** - For file operations, dependency updates

### Step 3: Create Atomic Commit

**Always create a descriptive commit:**

```bash
# Stage changes
git add [changed-files]

# Create commit with clear message
git commit -m "quick: [brief description]

[Detailed explanation if needed]

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>"
```

**Commit message format:**
- Prefix with `quick:` to indicate quick mode
- Brief description in present tense
- Optional detailed explanation
- Co-authored tag

### Step 4: Record in State

```bash
# Update state with quick task execution
"${HOME}/.claude-octopus/plugin/scripts/state-manager.sh" write_decision \
  "quick" \
  "$(git log -1 --pretty=%s)" \
  "Ad-hoc task executed in quick mode"

# Update metrics
"${HOME}/.claude-octopus/plugin/scripts/state-manager.sh" update_metrics \
  "execution_time" \
  "1"  # Estimated in minutes
```

### Step 5: Generate Summary

```bash
# Create quick task summary
mkdir -p .claude-octopus/quick

summary_file=".claude-octopus/quick/$(date +%Y%m%d-%H%M%S)-summary.md"

cat > "$summary_file" <<EOF
# Quick Task: $(git log -1 --pretty=%s)

## Task Description
$TASK_DESCRIPTION

## Changes Made
$(git diff HEAD~1..HEAD --stat)

## Files Modified
$(git diff --name-only HEAD~1..HEAD)

## Commit
$(git rev-parse HEAD)

## Timestamp
$(date -u +%Y-%m-%dT%H:%M:%SZ)

---
*Executed in Quick Mode - minimal overhead execution*
EOF

echo "📝 Summary saved to: $summary_file"
```

---

## Complete Example

**User Request:**
```
/octo:quick "fix typo in README - change 'recieve' to 'receive'"
```

**Execution:**

1. **Read the file**
   ```
   Read README.md to locate the typo
   ```

2. **Make the change**
   ```
   Edit README.md: replace "recieve" with "receive"
   ```

3. **Commit atomically**
   ```bash
   git add README.md
   git commit -m "quick: fix typo in README (recieve → receive)

   Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>"
   ```

4. **Record in state**
   ```bash
   state-manager.sh write_decision "quick" \
     "Fixed typo in README" \
     "Ad-hoc documentation fix"
   ```

5. **Generate summary**
   ```bash
   Created: .claude-octopus/quick/20260129-143045-summary.md
   ```

6. **Report to user**
   ```
   ✅ Fixed typo in README.md
   📝 Commit: abc123f
   📋 Summary: .claude-octopus/quick/20260129-143045-summary.md
   ```

---

## Benefits of Quick Mode

### Speed ⚡
- No multi-AI orchestration overhead
- Direct implementation
- Faster for simple tasks

### Cost Savings 💰
- No external provider API calls
- Only uses Claude (included with Claude Code)
- Efficient for ad-hoc work

### Still Tracked 📊
- Commits recorded
- State updated
- Summaries generated
- Full audit trail maintained

### Appropriate Scope 🎯
- Right tool for small tasks
- Doesn't over-engineer simple changes
- Reserves full workflows for complex work

---

## When Quick Mode Isn't Enough

If during execution you realize the task is more complex than expected:

**Stop and escalate to full workflow:**

```
This task is more complex than anticipated. I recommend using the full
workflow instead:

- For research: /octo:discover "research authentication patterns"
- For planning: /octo:define "define auth requirements"
- For building: /octo:develop "implement auth system"
- For validation: /octo:deliver "validate auth implementation"

Would you like me to switch to a full workflow?
```

**Indicators to escalate:**
- Multiple files need changes
- Requires architectural decisions
- Needs research or comparison
- Security implications
- Performance implications
- Breaking changes

---

## Directory Structure

Quick mode creates summaries in