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 SkillKit. 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:
- Claude acknowledges the mistake
- Proposes a rule to prevent it
- You approve → rule goes into memory
- 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 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: worktreein 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
- Changes Audit - List modified files, uncommitted changes
- State Check - Run
git status, tests, lint - Learning Capture - What mistakes? What worked?
- Next Session - What's next? Any blockers?
- 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
- After plan approval
- After each milestone
- Before destructive operations
- 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
Opus 4.6 and Sonnet 4.6 both support adaptive thinking and 1M-token context (as of 2025-08). The 1M context is available as a beta option (via the context-1m-2025-08-07 beta header); the default context window remains 200K. Sonnet 4.5 (200K context) has been retired from the Max plan in favor of Sonnet 4.6. See Models overview for current capabilities.
| Task | Model |
|---|---|
| Quick fixes, exploration | Haiku 4.5 |
| Features, balanced work | Sonnet 4.6 |
| Refactors, architecture | Opus 4.6 |
| Hard bugs, multi-system | Opus 4.6 |
Adaptive Thinking
Opus 4.6 and Sonnet 4.6 automatically calibrate reasoning depth per task — lightweight for simple operations, deep analysis for complex problems. No configuration needed. Extended thinking is built-in.
Add to CLAUDE.md
## Model Hints (as of 2025-08)
Opus 4.6 and Sonnet 4.6 auto-calibrate reasoning depth — no need to toggle thinking mode.
Use subagents with Haiku for fast read-only exploration, Sonnet 4.6 for balanced work.
Docs: https://docs.anthropic.com/en/docs/about-claude/models/overview
7. Context Discipline
200k tokens is precious. Manage it.
Rules
- Read before edit
- Compact at task boundaries
- Disable unused MCPs (<10 enabled, <80 tools)
- Summarize explorations
- Use subagents to isolate high-volume output (tests, logs, docs)
Context Compaction
- Auto-compacts at ~95% capacity (keeps long-running agents alive)
- Configure earlier compaction:
CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=50 - 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
## 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:
## Pro Workflow
### Self-Correction
When corrected, propose rule → add to LEARNED