Fix TODOs

Fix TODOs

I'll systematically find and resolve TODO comments in your codebase with intelligent understanding and continuity across sessions.

Arguments: $ARGUMENTS - files, directories, or specific TODO patterns to fix

Token Optimization Strategy

Target: 60% reduction (3,000-5,000 → 1,200-2,000 tokens)

This skill implements aggressive optimization for TODO resolution workflows by minimizing file reads, leveraging session state, and using progressive fixing patterns.

Core Optimization Patterns

1. Grep-First TODO Discovery (Primary: 60-70% savings)

# ALWAYS use Grep to find TODOs - never Read files for scanning
grep -rn "TODO|FIXME|HACK|XXX" --include="*.{js,ts,py,go}" .
grep "TODO:" src/ -C 2  # Get 2 lines context for understanding

# ANTI-PATTERN: Reading files to find TODOs
# Read each .js file  # ❌ NEVER do this

2. Session-Based State Tracking (80% savings on resume)

fix-todos/
├── plan.md           # All TODOs with resolution status
├── state.json        # Current progress, decisions, context
└── resolutions/      # Completed TODO resolutions for reference

**Session state prevents re-scanning and re-analyzing:

• Check for fix-todos/ directory FIRST
• If state.json exists, resume from last TODO
• Only scan for new TODOs if explicitly requested
• Use cached TODO inventory and context

3. Git Diff for Changed Files with TODOs (70% savings)

# Find files with TODOs that changed recently
git diff --name-only HEAD~5 | xargs grep -l "TODO"

# Focus on changed files vs full codebase scan
git diff --name-only | grep -f todo-files.txt

4. Progressive TODO Resolution (one at a time)

• Fix ONE TODO per iteration
• Update state after each fix
• Commit incrementally
• User can continue/​stop at any point
• Reduces context loading by 70%

5. Early Exit Patterns

# Check for session FIRST
ls fix-todos/​state.json 2>/​dev/​null && echo "Session exists"

# Check for TODOs before scanning
grep -q "TODO" . || echo "No TODOs found"

# Skip fixed TODOs from state
grep "^FIXED:" fix-todos/​plan.md | wc -l

Optimization Decision Tree

START
├── Session exists? (check fix-todos/​state.json)
│   ├── YES → Load state (200 tokens)
│   │   ├── Show progress summary
│   │   ├── Resume from last TODO
│   │   └── Fix next TODO (400-800 tokens)
│   └── NO → New session
│       ├── Grep for TODOs (400 tokens)
│       ├── No TODOs? → Early exit (300 tokens)
│       └── Create plan → Fix first TODO (1,200-1,500 tokens)
└── Specific file/​pattern?
    ├── Grep in scope only (300 tokens)
    └── Fix matching TODOs (800-1,200 tokens)

Token Cost Breakdown

Initial Session (1,200-2,000 tokens):

• Check for session: 100 tokens
• Grep for TODOs: 300-400 tokens
• Categorize TODOs: 200-300 tokens
• Create plan: 200-400 tokens
• Fix first TODO: 400-900 tokens (Read file, Edit, verify)

Resume Session (400-800 tokens):

• Load state: 100-200 tokens
• Show progress: 100 tokens
• Read file with next TODO: 200-300 tokens
• Fix TODO: 200-300 tokens

Specific File Focus (800-1,200 tokens):

• Grep in file: 100-200 tokens
• Read file: 300-400 tokens
• Fix TODOs: 400-600 tokens

Template-Based Resolution Patterns

Cache common TODO resolution templates:

// Error handling template
TODO_TEMPLATES = {
  error_handling: "try { /​* existing */ } catch (err) { logger.error(err); throw err; }",
  validation: "if (!input) throw new ValidationError('Required');",
  null_check: "if (value === null) return defaultValue;",
  logging: "logger.debug('Operation:', { context });",
  type_guard: "if (typeof x !== 'expected') throw new TypeError();"
}

// Use templates instead of analyzing patterns every time

Caching Strategy

Session Location: fix-todos/ (current project directory)

• plan.md - TODO inventory with status
• state.json - Progress, decisions, current TODO
• resolutions/ - Completed fixes for pattern matching

Cache Location: .claude/​cache/​fix-todos/

• todo-inventory.json - All TODOs found
• resolution-patterns.json - Your code patterns
• context-snippets/ - Related code for each TODO

Cache Validity: Until session completed or user runs fix-todos new

Cache Sharing: /​find-todos, /​create-todos, /​todos-to-issues can reuse TODO inventory

Practical Token Savings Examples

Example 1: Resume existing session

BEFORE optimization (3,500 tokens):
- Re-scan all files for TODOs: 1,200 tokens
- Re-categorize: 400 tokens
- Re-create plan: 500 tokens
- Find next TODO: 300 tokens
- Fix TODO: 1,100 tokens

AFTER optimization (500 tokens):
- Load state: 100 tokens
- Read next TODO file: 200 tokens
- Fix TODO: 200 tokens
Savings: 3,000 tokens (86%)

Example 2: Fix TODOs in specific file

BEFORE optimization (4,000 tokens):
- Read all project files: 2,000 tokens
- Find TODOs everywhere: 800 tokens
- Filter to target file: 200 tokens
- Fix TODOs: 1,000 tokens

AFTER optimization (1,000 tokens):
- Grep in specific file: 200 tokens
- Read file: 300 tokens
- Fix TODOs: 500 tokens
Savings: 3,000 tokens (75%)

Example 3: New session with no TODOs

BEFORE optimization (2,000 tokens):
- Read many files looking for TODOs: 1,800 tokens
- Report none found: 200 tokens

AFTER optimization (300 tokens):
- Grep entire codebase: 200 tokens
- Report none found (early exit): 100 tokens
Savings: 1,700 tokens (85%)

Usage Patterns by Token Cost

High-efficiency commands (400-800 tokens):

• fix-todos resume - Continue existing session
• fix-todos src/​api/​auth.js - Specific file
• fix-todos status - Check progress only

Medium-efficiency commands (1,200-1,500 tokens):

• fix-todos - New session (first time)
• fix-todos src/ - Directory scope
• fix-todos "security" - Pattern filter

Avoid if possible (2,000+ tokens):

• fix-todos new when session already exists
• Re-scanning without using cached results
• Fixing all TODOs at once (use progressive mode)

Optimization Checklist

Before TODO Discovery:

• ✅ Check for fix-todos/​state.json FIRST
• ✅ Load cached TODO inventory if available
• ✅ Use Grep (not Read) for TODO scanning
• ✅ Apply scope filters early (file/​pattern)
• ✅ Early exit if no TODOs found

During TODO Resolution:

• ✅ Fix ONE TODO at a time (progressive mode)
• ✅ Use git diff to find changed files
• ✅ Apply resolution templates when possible
• ✅ Update state after each fix
• ✅ Commit incrementally

After TODO Resolution:

• ✅ Cache resolution patterns for future use
• ✅ Update plan.md with completion status
• ✅ Persist state for next session
• ✅ Clean up session when all TODOs fixed

Anti-Patterns to Avoid

❌ Reading all files to find TODOs → Use Grep ❌ Re-scanning on every resume → Use session state ❌ Fixing all TODOs in one iteration → Progressive mode ❌ Not checking for existing session → Load state first ❌ Not using cached patterns → Apply templates ❌ Full codebase analysis per TODO → Incremental context

Expected Performance

Token Usage:

• Initial session: 1,200-2,000 tokens
• Resume session: 400-800 tokens
• Specific file: 800-1,200 tokens
• Average: 1,200 tokens (vs 3,000-5,000 unoptimized)

Reduction: 60-75% (exceeds 60% target)

Optimization Status: ✅ Optimized (Phase 2 Batch 3D-F, 2026-01-26)

Session Intelligence

I'll maintain TODO resolution progress across sessions:

Session Files (in current project directory):

• fix-todos/​plan.md - All TODOs found and resolution status
• fix-todos/​state.json - Current progress and decisions

IMPORTANT: Session files are stored in a fix-todos folder in your current project directory

Auto-Detection:

• If session exists: Resume from last TODO
• If no session: Scan and create new plan
• Commands: resume, status, new

Phase 1: Discovery & Analysis

MANDATORY FIRST STEPS:

1. Check if fix-todos directory exists in current working directory
2. If directory exists, check for session files:
   • Look for fix-todos/​state.json
   • Look for fix-todos/​plan.md
   • If found, resume from existing session
3. If no directory or session exists:
   • Scan entire codebase for TODOs
   • Create categorized plan
   • Initialize progress tracking
4. Show TODO summary before starting

I'll find and categorize all TODOs:

TODO Detection:

• TODO, FIXME, HACK, XXX markers
• Different priority levels
• Context and complexity assessment
• Related code understanding

Smart Categorization:

• Quick fixes: Simple validations, null checks
• Features: Missing functionality
• Refactoring: Code improvements
• Security: Safety and validation needs
• Performance: Optimization opportunities

Phase 2: Resolution Planning

Based on analysis, I'll create a resolution plan:

Priority Order:

1. Security-critical TODOs
2. Bug-related TODOs
3. Simple improvements
4. Feature additions
5. Performance optimizations

I'll write this plan to fix-todos/​plan.md with:

• Each TODO location and content
• Proposed resolution approach
• Risk assessment
• Implementation order

Phase 3: Intelligent Resolution

I'll fix TODOs matching your code patterns:

Pattern Detection:

• Find similar implementations in your code
• Match your error handling style
• Use your validation patterns
• Follow your naming conventions

Resolution Strategies:

• Error handling → Your try/​catch patterns
• Validation → Your input checking style
• Performance → Your optimization approach
• Security → Your safety patterns

Phase 4: Incremental Implementation

I'll resolve TODOs systematically:

Execution Process:

1. Create git checkpoint
2. Fix TODO with contextual understanding
3. Verify functionality preserved
4. Update plan with completion
5. Move to next TODO

Progress Tracking:

• Mark each TODO as resolved in plan
• Update state file with decisions
• Create meaningful commits

Phase 5: Verification

After each resolution:

• Run relevant tests
• Check for regressions
• Validate integration points
• Ensure code quality

Context Continuity

Session Resume: When you return and run /​fix-todos or /​fix-todos resume:

• Load existing plan and progress
• Show completion statistics
• Continue from last TODO
• Maintain all resolution decisions

Progress Example:

RESUMING TODO FIXES
├── Total TODOs: 47
├── Resolved: 23 (49%)
├── Current: src/​api/​auth.js:42
└── Next: src/​utils/​validation.js:15

Continuing resolution...

Practical Examples

Start Fixing:

/​fix-todos                    # Fix all TODOs
/​fix-todos src/              # Focus on directory
/​fix-todos "security"        # Fix security TODOs

Session Control:

/​fix-todos resume    # Continue existing session
/​fix-todos status    # Check progress
/​fix-todos new       # Start fresh

Safety Guarantees

Protection Measures:

• Git checkpoint before changes
• Incremental commits
• Functionality verification
• No TODO removal without implementation

Important: I will NEVER:

• Remove TODOs without fixing them
• Break existing functionality
• Add AI attribution
• Implement without understanding context

Command Suggestions

After resolving critical TODOs:

• /​test - To ensure fixes work correctly
• /​commit - To save TODO resolutions

What I'll Actually Do

1. Scan comprehensively - Find all TODOs with context
2. Plan strategically - Order by priority and risk
3. Resolve intelligently - Match your patterns
4. Track meticulously - Perfect session continuity
5. Verify constantly - Ensure quality maintained

I'll maintain complete continuity between sessions, always resuming exactly where we left off with full context of previous resolutions.