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.
Installs just this skill. Get the whole plugin for auto-invocation.
⚡ How it fires
How this skill gets triggered: by you, by Claude, or both.
Fires itselfClaude auto-loads it when your prompt matches the work.
You can call itInvoke it directly when you want it.
Slash command/pro-workflow
👁️ Context preview
The summary Claude sees to decide when to auto-load this skill.
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.
---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
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
```text
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.
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
```markdown
## 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:**
```bash
claude --worktree # or claude -w (auto-creates isolated worktree)
```
**Cursor / Any editor:**
```bash
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
```markdown
## 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`:
```markdown
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
```text
.claude/
├── CLAUDE.md # Entry point
├── AGENTS.md # Workflow rules
├── SOUL.md # Style preferences
└── LEARNED.md # Auto-populated
```
### AGENTS.md
```markdown
# 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
```markdown
# 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
```markdown
## 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 setting decide output quality more than the model choice. See [`references/models-2026.md`](../../references/models-2026.md) for strings, prices, and routing.
| Task | Model | Effort |
|------|-------|--------|
| Quick fixes, lookups | Haiku 4.5 | low |
| Features, balanced work | Sonnet 5 | high |
| Refactors, architecture, hard debug | Opus 4.8 | xhigh |
Fixed thinking budgets are retired on the current tiers. Control depth with `effort` (`low` through `xhigh` to `max`); `xhigh` is the default for coding and agentic work. Adaptive thinking lets the model calibrate reasoning per step with no fixed budget. Run grunt subagents at `low` effort on Haiku and keep the reasoning path on the capable tier.
### Add to CLAUDE.md
```markdown
## Model Hints
Route by task: Haiku 4.5 for lookups, Sonnet 5 for features, Opus 4.8 for
architecture and hard debugging, Fable 5 for long-horizon builds.
Effort is the lever, not thinking budgets: xhigh for coding, low for subagents.
```
---
## 7. Context Discipline
200k tokens is precious. Manage it.
### Rules
1. Read before edit
2. Compact at task boundaries
3. Disable unused MCPs (<10 enabled, <80 tools)
4. Summarize explorations
5. Use subagents to isolate high-volume output (tests, logs, docs)
### Context Compaction
- Auto-compacts at ~95% capacity (keeps long-running agents alive)
- Use PreCompact hooks to save state before compaction
- Subagents auto-compact independently from the main session
### Good Compact Points
- After planning, before execution
- After completing a feature
- When context >70%
- Before switching task domains
---
## 8. Learning Log
Auto-document insights from sessions.
### Add to CLAUDE.md
```markdown
## Learning Log
After tasks, note learnings:
`[DATE] [TOPIC]: Key insight`
Append to .claude/learning-log.md
```
---
## Learn Claude Code
Run `/learn` for a topic-by-topic guide covering sessions, context, CLAUDE.md, subagents, hooks, and more (see `commands/learn.md`). Official docs: **https://code.claude.com/docs/**
---
## Quick Setup
### Minimal
Add to your CLAUDE.md:
```markdown
## Pro Workflow
### Self-Correction
When corrected, propose rule → add to LEARNED after approval.
