Task Complexity Routing

The productivity paradox emerges when sophisticated systems become obstacles to simple work. AI workflows optimized for complex tasks create friction for trivial changes. The button needs to change from red to blue, but the system demands research phases, verification protocols, and architectural review. The overhead inverts the value proposition.

Task complexity exists on a spectrum, but most workflows treat every request identically. A single-file CSS change receives the same procedural weight as a multi-service integration. The planning overhead for simple tasks exceeds the execution cost by orders of magnitude. This creates systematic inefficiency where users bypass the workflow entirely, losing state tracking and organizational benefits.

The resolution requires routing logic based on task classification. Simple tasks need fast execution paths that maintain organizational benefits without procedural overhead. Complex tasks retain full workflow protections. The challenge lies in reliable classification and maintaining state coherence across both paths.

Complexity Assessment Framework

Task classification determines workflow routing. The assessment must happen before planning begins, preventing sunk overhead costs. Clear boundaries prevent scope creep and workflow bypassing.

Add to CLAUDE.md:

Before starting any task, assess complexity: SIMPLE (single file change, styling, small additions) → use quick execution path with minimal planning. COMPLEX (multi-file, architecture changes, integrations) → use full planning workflow with research and verification phases. When uncertain, default to COMPLEX path.

The classification boundary matters more than perfect categorization. Defaulting to complex workflows when uncertain prevents underestimation costs. Simple task misclassification wastes time; complex task misclassification wastes weeks.

Quick Execution Implementation

Simple tasks require streamlined execution while preserving organizational benefits. The quick path eliminates research, verification, and approval phases but maintains state tracking and project structure.

Create quick-execute skill:

The skill handles lightweight task execution for simple changes. First, it creates numbered folder structure (quick/001/) maintaining project organization. Second, it generates minimal plan without research phase. Third, it executes immediately with basic error checking. Fourth, it creates summary and commits changes with proper git history.

Implement /quick command for simple tasks:

Stage 1 parses simple task prompt and creates folder structure under ‘quick/’ directory. Stage 2 sends to Claude for immediate plan generation without research phase. Stage 3 executes plan directly if confidence exceeds basic feasibility threshold, otherwise escalates to full workflow.

The quick path trades comprehensive planning for execution speed. Error rates increase slightly, but the cost differential favors quick execution for genuinely simple tasks. Rollback mechanisms handle the edge cases where simple classification proves incorrect.

State Tracking for Quick Tasks

Quick execution must preserve organizational benefits that make workflows valuable. State tracking, git history, and project documentation remain essential even for simple changes.

Implement state tracking for quick tasks:

For quick tasks, create numbered folders (001, 002, etc.) under ‘quick/’ directory. Each folder contains: plan file (001-plan.md), summary file (001-summary.md), and any generated artifacts. Maintains git history and project organization even for simple tasks. Log task classification decision in summary for future reference.

The numbered folder structure provides consistency across workflow paths. Future debugging benefits from uniform state representation regardless of execution complexity. The classification decision logged in summary enables workflow optimization analysis.

Automated Git Integration

Post-execution git operations create friction that users often skip. Automating commit messages, changelog updates, and documentation refresh removes manual overhead while preserving project hygiene.

Create publish-manager subagent:

Input: Completed task folder with plan and summary files. Process: Checks uncommitted files, generates commit message from task summary, updates project changelog with task reference, creates git commit with proper metadata. Output: Clean working directory with proper git history and updated documentation.

The publish manager standardizes git operations across both workflow paths. Commit message generation from task summaries provides consistency. Changelog automation ensures project history remains current without manual maintenance.

CLI-First Deployment Strategy

AI agents struggle with GUI-based deployment tools. CLI-first approaches enable autonomous deployment and debugging without human intervention for interface navigation.

Create CLI-first deployment skill:

The skill prioritizes CLI-based deployment tools (Fly.io, Railway, Vercel CLI) over GUI tools for AI agent compatibility. First, it provides templates for CLI authentication setup. Second, it configures environment variables through command-line interfaces. Third, it creates deployment pipelines executable by AI agents. Fourth, it includes debugging commands for deployment issues.

CLI tools provide deterministic interfaces that AI agents can execute reliably. Error messages from CLI tools are parseable and actionable. GUI tools require human interpretation and manual clicking that breaks autonomous workflows.

The synthesis reveals workflow stratification based on complexity thresholds. Quick execution preserves essential organizational benefits while eliminating procedural overhead. Full workflows retain comprehensive protections for complex work. The routing logic prevents both over-engineering simple tasks and under-planning complex ones. The deeper pattern: complexity assessment must precede methodology selection, not follow it.