thoroughness
- Repo stars 113
- License MIT
- Author repo prpm
- Domain
- Other
- Author-declared agents
- No explicit declaration found; this is not inferred or tested compatibility
- Static check
- 94 / 100 · heuristic scan, not runtime safety proof
- Runtime evidence
- Not run; no isolated runtime test evidence is currently recorded
- Author / version / license
- @pr-pm · MIT
- Token usage
- Lean
- Setup complexity
- Plug-and-play
- External API key
- Not required
- Operating systems
- Unspecified (assume cross-platform)
- Runtime requirements
- No explicit requirements detected
- Detected file/system behavior
-
- Read-only
- Write / modify
- Network behavior
- External requests
- Install commands
- None (reference only)
Heads up: Tool permissions are not declared; actual access depends on the runtime.
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)
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
Phase 3: Comprehensive Verification (20% of time)
Run All Tests Unit tests Integration tests E2E tests Manual verification
# Thoroughness
## Purpose
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)
1. **Identify All Issues**
- List every error, warning, and failing test
- Group related issues together
- Prioritize by dependency order
- Create issue hierarchy (what blocks what)
2. **Root Cause Analysis**
- Don't fix symptoms, find root causes
- Trace errors to their source
- Identify patterns in failures
- Document assumptions that were wrong
3. **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)
1. **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
2. **Verify Each Fix**
- Write/run tests for the specific fix
- Check for side effects
- Verify related functionality still works
- Document test results
3. **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)
1. **Run All Tests**
- Unit tests
- Integration tests
- E2E tests
- Manual verification
2. **Cross-Check Everything**
- Review all changed files
- Verify compilation succeeds
- Check for console errors/warnings
- Test edge cases
3. **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)
- Quality: Near-perfect first time
- Maintenance: Minimal
## Success Metrics
- ✅ 100% of tests passing
- ✅ Zero warnings in production build
- ✅ All code has test coverage
- ✅ Documentation is complete and accurate
- ✅ No known issues or TODOs left behind
- ✅ Future developers can understand the code
## Mantras
- "Slow is smooth, smooth is fast"
- "Do it right the first time"
- "Test everything, assume nothing"
- "Document for your future self"
- "Root causes, not symptoms"
Sections and files
Listed in source order.
sections -> Purpose → When to Use → Methodology → Phase 1: Comprehensive Analysis (20% of time) → Phase 2: Systematic Implementation (60% of time) → Phase 3: Comprehensive Verification (20% of time)
terms -> Identify All Issues · Root Cause Analysis · Create Detailed Plan · Fix Issues in Dependency Order · Verify Each Fix · Track Progress · Run All Tests · Cross-Check Everything
files/cmd -> breaks/checkpoints · Write/run · errors/warnings · types/tar · registry-client.ts
body sha256 -> cf0b2f193f18
Purpose
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
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)
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
Phase 3: Comprehensive Verification (20% of time)
Run All Tests Unit tests Integration tests E2E tests Manual verification