Use when implementing complex multi-step tasks, fixing critical bugs, or when quality and completeness matter more than speed - ensures comprehensive implementation without shortcuts through systematic analysis, implementation, and verification phases
This skill ensures comprehensive, complete implementation of complex tasks without shortcuts. Use this when quality and completeness matter more than speed.
When to Use
Fixing critical bugs or compilation errors
Implementing complex multi-step features
Debugging test failures
Refactoring large codebases
Production deployments
Any task where shortcuts could cause future problems
Methodology
Phase 1: Comprehensive Analysis (20% of time)
Identify All Issues
List every error, warning, and failing test
Group related issues together
Prioritize by dependency order
Create issue hierarchy (what blocks what)
Root Cause Analysis
Don't fix symptoms, find root causes
Trace errors to their source
Identify patterns in failures
Document assumptions that were wrong
Create Detailed Plan
Break down into atomic steps
Estimate time for each step
Identify dependencies between steps
Plan verification for each step
Schedule breaks/checkpoints
Phase 2: Systematic Implementation (60% of time)
Fix Issues in Dependency Order
Start with foundational issues
Fix one thing completely before moving on
Test after each fix
Document what was changed and why
Verify Each Fix
Write/run tests for the specific fix
Check for side effects
Verify related functionality still works
Document test results
Track Progress
Mark issues as completed
Update plan with new discoveries
Adjust time estimates
Note any blockers immediately
Phase 3: Comprehensive Verification (20% of time)
Run All Tests
Unit tests
Integration tests
E2E tests
Manual verification
Cross-Check Everything
Review all changed files
Verify compilation succeeds
Check for console errors/warnings
Test edge cases
Documentation
Update relevant docs
Add inline comments for complex fixes
Document known limitations
Create issues for future work
Anti-Patterns to Avoid
❌ Fixing multiple unrelated issues at once
❌ Moving on before verifying a fix works
❌ Assuming similar errors have the same cause
❌ Skipping test writing "to save time"
❌ Copy-pasting solutions without understanding
❌ Ignoring warnings "because it compiles"
❌ Making changes without reading existing code first
Quality Checkpoints
Can I explain why this fix works?
Have I tested this specific change?
Are there any side effects?
Is this the root cause or a symptom?
Will this prevent similar issues in the future?
Is the code readable and maintainable?
Have I documented non-obvious decisions?
Example Workflow
Bad Approach (Shortcut-Driven)
1. See 24 TypeScript errors
2. Add @ts-ignore to all of them
3. Hope tests pass
4. Move on
Good Approach (Thoroughness-Driven)
1. List all 24 errors systematically
2. Group by error type (7 missing types, 10 unknown casts, 7 property access)
3. Find root causes:
- Missing @types/tar package
- No type assertions on fetch responses
- Implicit any types in callbacks
4. Fix by category:
- Install @types/tar (fixes 7 errors)
- Add proper type assertions to registry-client.ts (fixes 10 errors)
- Add explicit parameter types (fixes 7 errors)
5. Test after each category
6. Run full test suite
7. Document what was learned
Time Investment
Initial: 2-3x slower than shortcuts
Long-term: 10x faster (no debugging later, no rework)