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"

thoroughness