# /grid:quick - Quick Task Execution

---
name: grid:quick
description: Fast task execution without full planning ceremony
context: fork
agent: general-purpose
argument-hint: "[task description]"
allowed-tools:
  - Read
  - Write
  - Edit
  - Bash
  - Glob
  - Grep
  - Task
  - AskUserQuestion
---

Execute simple tasks without the full Cluster/Block/Thread breakdown. For bug fixes, small features, refactoring, and documentation.

## USAGE

`/grid:quick "description of what to do"`

## WHEN TO USE

**Good for:**
- Bug fixes
- Small features (< 3 tasks)
- Refactoring tasks
- Documentation updates
- Configuration changes
- Quick prototypes

**Use full /grid for:**
- New features requiring planning
- Multi-phase work
- Architectural changes
- Complex integrations

## PROCESS

### 1. Quick Questioning (Max 2 questions)

Only ask clarifying questions if absolutely necessary:
- What exactly should happen?
- Any constraints I should know?

Skip if the request is clear enough.

### 2. Quick Planning (Single PLAN.md)

Create a lightweight plan at `.grid/quick/{timestamp}-{slug}/PLAN.md`:

```markdown
---
type: quick
created: {ISO timestamp}
description: "{user description}"
---

# Quick Task: {Description}

## Objective
{What we're doing}

## Threads
1. {Thread 1}
2. {Thread 2}
3. {Thread 3 if needed}

## Done When
{Completion criteria}
```

### 3. Execute Immediately

Execute all threads without spawning separate Executor agents (quick tasks stay in current context to minimize overhead).

Per-thread commits:
```
feat(quick): {description}
```

### 4. Create SUMMARY.md

After completion:

```markdown
---
type: quick
completed: {ISO timestamp}
duration: {time}
commits: [{hashes}]
---

# Quick Task Summary: {Description}

## Accomplished
- {What was done}

## Files Modified
- `{file1}`
- `{file2}`

## Commits
- {hash}: {message}
```

## DIRECTORY STRUCTURE

```
.grid/
└── quick/
    ├── 20240123-140530-add-dark-mode/
    │   ├── PLAN.md
    │   └── SUMMARY.md
    └── 20240123-151200-fix-login-bug/
        ├── PLAN.md
        └── SUMMARY.md
```

## OUTPUT FORMAT

### Starting

```
QUICK TASK
══════════

{Description}

Threads:
├─ {Thread 1}
├─ {Thread 2}
└─ {Thread 3}

Executing...
```

### Progress

```
├─ Thread 1: ✓ Complete ({commit})
├─ Thread 2: ⚡ In progress...
└─ Thread 3: ○ Pending
```

### Completion

```
QUICK TASK COMPLETE
═══════════════════

{Description}

Commits:
- {hash}: {message}
- {hash}: {message}

SUMMARY: .grid/quick/{path}/SUMMARY.md

End of Line.
```

## CONSTRAINTS

- Max 3 threads
- No checkpoints (quick tasks run to completion)
- No Recognizer verification (for quick tasks)
- Stays in current context (no subagent spawning)
- Commits immediately after each thread

## RULES

1. Keep it simple - if it needs planning, use /grid
2. Max 3 threads - split if more needed
3. Direct execution - no spawning for overhead
4. Atomic commits - one per thread
5. Document in SUMMARY.md - leave trail

End of Line.