Help us improve
Share bugs, ideas, or general feedback.
From fullstack-agents
Resolve runtime and compile-time errors as a batch operation, not iteratively.
npx claudepluginhub adelabdelgawad/fullstack-agents --plugin fullstack-agentsHow this skill is triggered — by the user, by Claude, or both
Slash command
/fullstack-agents:batch-error-resolutionThe summary Claude sees in its skill listing — used to decide when to auto-load this skill
Resolve runtime and compile-time errors as a batch operation, not iteratively.
Iterative error-crusher loop that auto-stops at 0 errors. Cascade-aware: fixes dependency errors before their dependents. Refuses anti-patterns that hide errors instead of fixing them. TRIGGER when: user has errors or failures to fix iteratively; user asks to "fix all errors"; user has a failing test suite; user has compilation errors; user has linter errors; user wants systematic error elimination; user invokes /autoresearch:fix. DO NOT TRIGGER when: user wants a one-shot fix for a single obvious bug; user wants debugging guidance only; user wants code review without fixing.
Diagnoses and fixes TypeScript compile errors, runtime exceptions, build failures, and test issues in JavaScript/Node.js projects via linting, dependency reinstalls, and code patterns. Use for task failures.
Diagnoses and fixes test failures, build errors, runtime errors, environment issues, and more by categorizing errors and applying targeted strategies with minimal context.
Share bugs, ideas, or general feedback.
Resolve runtime and compile-time errors as a batch operation, not iteratively.
Use this skill when:
Do NOT use for: Single, isolated errors that can be fixed immediately.
Errors are batch operations, not iterative loops.
Re-running compiler/tests after each fix wastes time and creates noise. Fix ALL errors first, then verify once.
┌─────────────────────────────────────────────────────────────┐
│ 1. COLLECT - Gather all errors from output │
│ • List every error explicitly │
│ • Do NOT attempt fixes yet │
└──────────────────────────┬──────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────┐
│ 2. ANALYZE - Study errors together │
│ • Identify shared root causes │
│ • Find dependency relationships between errors │
│ • Spot opportunities for single-fix-multiple-errors │
└──────────────────────────┬──────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────┐
│ 3. RESOLVE - Apply all fixes │
│ • Work on errors conceptually in parallel │
│ • No partial or speculative fixes │
│ • Address every listed error │
└──────────────────────────┬──────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────┐
│ 4. VERIFY - Single re-run after ALL fixes complete │
│ • Only now run compiler/tests/linter │
│ • Confirm no new errors introduced │
└─────────────────────────────────────────────────────────────┘
Do NOT re-run:
Until: Every error in the collected list has been addressed.
| Don't Do | Why It's Wrong |
|---|---|
| Fix one error, run tests, fix next | Wastes cycles, creates noise |
| Re-run checks after each fix | Same error cascade repeats |
| Ignore secondary/cascading errors | They may reveal root cause |
| Trial-and-error debugging | Undisciplined, slow |
| Speculative "maybe this fixes it" | Fix what you understand |
When collecting errors, enumerate them explicitly:
## Collected Errors (7 total)
1. **TypeError** at `src/utils.ts:45` - Cannot read property 'id' of undefined
2. **TypeError** at `src/utils.ts:52` - Same root cause (uses result from line 45)
3. **ImportError** at `src/index.ts:3` - Module './missing' not found
4. **SyntaxError** at `src/parser.ts:88` - Unexpected token '}'
5. **TypeError** at `src/api.ts:12` - Argument type mismatch
6. **TypeError** at `src/api.ts:34` - Related to #5 (same function signature)
7. **ESLint** at `src/helpers.ts:15` - 'unused' is defined but never used
### Analysis
- Errors #1 and #2: Same root cause - null check missing at line 45
- Errors #5 and #6: Same root cause - function signature changed
- Error #3: Independent - missing file
- Error #4: Independent - syntax issue
- Error #7: Independent - dead code
Multiple errors often share a root cause:
10 type errors → 1 interface change
5 import errors → 1 renamed module
8 test failures → 1 broken fixture
Fix the root cause, not each symptom.
Some errors depend on others:
Error A: Function signature wrong
Error B: Call to function fails (depends on A)
Error C: Test of function fails (depends on A)
Fix A first. B and C may resolve automatically.
Work on independent errors mentally in parallel:
While fixing Error #1 in file A:
- Note what Error #3 in file B needs
- Note what Error #5 in file C needs
Then apply all fixes before re-running anything.
| Phase | Action | Output |
|---|---|---|
| Collect | Run build/test once | Numbered error list |
| Analyze | Study relationships | Root causes identified |
| Resolve | Apply ALL fixes | All errors addressed |
| Verify | Single re-run | Clean or new error list |
| Mistake | Fix |
|---|---|
| "Let me just run tests to see if that worked" | No. Complete all fixes first. |
| "This error might be related" | Don't guess. Analyze the full list. |
| "I'll fix the easy ones first" | Fix by root cause, not difficulty. |
| "The cascade is too long to read" | Read it. That's the job. |