/pro-workflow

name: pro-workflow
description: Complete AI coding workflow system. Orchestration patterns, 18 hook events, 8 agents, cross-agent support, reference guides, and searchable learnings. Works with Claude Code, Cursor, and 32+ agents.

Pro Workflow

Complete AI coding workflow system from production use. Orchestration patterns, reference guides, and battle-tested habits that compound over time.

**Works with:** Claude Code, Cursor, Codex, Gemini CLI, and 32+ AI coding agents via skills add. Sections marked *(Claude Code)* use features specific to Claude Code — Cursor users can skip those or use the noted alternatives.

The Core Insight

> "80% of my code is written by AI, 20% is spent reviewing and correcting it." — Karpathy

This skill optimizes for that ratio. Every pattern here reduces correction cycles.

---

1. The Self-Correction Loop

**The single most powerful pattern.** Your CLAUDE.md trains itself through corrections.

How It Works

When you correct Claude: 1. Claude acknowledges the mistake 2. Proposes a rule to prevent it 3. You approve → rule goes into memory 4. Future sessions avoid the same mistake

Add to CLAUDE.md

## Self-Correction Protocol

When the user corrects me or I make a mistake:
1. Acknowledge specifically what went wrong
2. Propose a concise rule: `[LEARN] Category: One-line rule`
3. Wait for approval before adding to LEARNED section

### LEARNED
<!-- Auto-populated through corrections -->

Trigger Phrases

• "Add that to your rules"
• "Remember this"
• "Don't do that again"

Example Flow

User: You edited the wrong file
Claude: I edited src/utils.ts when you meant src/lib/utils.ts.

[LEARN] Navigation: Confirm full path before editing files with common names.

Should I add this?

---

1b. Pre-Flight Discipline

**Self-correction catches mistakes after the fact. This catches them before.**

Karpathy's [observations on LLM coding pitfalls](https://x.com/karpathy/status/2015883857489522876) name the upstream failures: silent assumptions, overcomplicated diffs, drive-by edits, vague success criteria. Four rules prevent each one.

| Rule | Prevents | |------|----------| | **Surface, don't assume** | Wrong interpretation, hidden confusion, missing tradeoffs | | **Minimum viable code** | 200-line diffs that should be 50, speculative abstractions | | **Stay in your lane** | Drive-by refactors, "improvements" to adjacent code | | **Verifiable goals** | Endless re-clarification, "make it work" loops |

Full rules in `rules/pre-flight-discipline.mdc` (`alwaysApply: true`). Pairs with self-correction: pre-flight stops the mistake, self-correction captures the lesson when one slips through.

Add to CLAUDE.md

## Pre-Flight Discipline
Before coding: state assumptions, present ambiguity, push back if simpler exists.
Every changed line traces to the request - no drive-by edits.
Convert imperatives to verifiable goals: "fix bug" → "failing test → make it pass".

---

2. Parallel Sessions with Worktrees

**Zero dead time.** While one Claude thinks, work on something else.

Setup

**Claude Code:**

claude --worktree    # or claude -w (auto-creates isolated worktree)

**Cursor / Any editor:**

git worktree add ../project-feat feature-branch
git worktree add ../project-fix bugfix-branch

Background Agent Management *(Claude Code)*

• `Ctrl+F` — Kill all background agents (two-press confirmation)
• `Ctrl+B` — Send task to background
• Subagents support `isolation: worktree` in agent frontmatter

When to Parallelize

| Scenario | Action | |----------|--------| | Waiting on tests | Start new feature in worktree | | Long build | Debug issue in parallel | | Exploring approaches | Try 2-3 simultaneously |

Add to CLAUDE.md

## Parallel Work
When blocked on long operations, use `claude -w` for instant parallel sessions.
Subagents with `isolation: worktree` get their own safe working copy.

---

3. The Wrap-Up Ritual

End sessions with intention. Capture learnings, verify state.

/wrap-up Checklist

1. **Changes Audit** - List modified files, uncommitted changes 2. **State Check** - Run `git status`, tests, lint 3. **Learning Capture** - What mistakes? What worked? 4. **Next Session** - What's next? Any blockers? 5. **Summary** - One paragraph of what was accomplished

Create Command

`~/.claude/commands/wrap-up.md`:

Execute wrap-up checklist:
1. `git status` - uncommitted changes?
2. `npm test -- --changed` - tests passing?
3. What was learned this session?
4. Propose LEARNED additions
5. One-paragraph summary

---

4. Split Memory Architecture

For complex projects, modularize Claude memory.

Structure

.claude/
├── CLAUDE.md        # Entry point
├── AGENTS.md        # Workflow rules
├── SOUL.md          # Style preferences
└── LEARNED.md       # Auto-populated

AGENTS.md

# Workflow Rules

## Planning
Plan mode when: >3 files, architecture decisions, multiple approaches.

## Quality Gates
Before complete: lint, typecheck, test --related.

## Subagents
Use for: parallel exploration, background tasks.
Avoid for: tasks needing conversation context.

SOUL.md

# Style

- Concise over verbose
- Action over explanation
- Acknowledge mistakes directly
- No features beyond scope

---

5. The 80/20 Review Pattern

Batch reviews at checkpoints, not every change.

Review Points

1. After plan approval 2. After each milestone 3. Before destructive operations 4. At /wrap-up

Add to CLAUDE.md

## Review Checkpoints
Pause for review at: plan completion, >5 file edits, git operations, auth/security code.
Between: proceed with confidence.

---

6. Model Selection

**Current lineup (2026):** Fable 5, Opus 4.8, Sonnet 5, and Haiku 4.5. The flagship tiers carry a 1M-token context; Haiku 4.5 is 200K. Frontier models converged, so the harness and the effort