deslop-code

Aggressively reduce code. Every line must earn its place — strip AI artifacts, remove bloat, and shrink files to their essence while preserving clarity and correctness.

Scope

Default: files changed on the current branch vs main (git diff --name-only main...HEAD). If the user specifies files, directories, or patterns, use those instead.

Process

1. Get the file list for the scope above
2. Read each file completely — understand what it does before touching it
3. Apply reductions file by file, using all applicable techniques below
4. After all edits, run any available tests/typecheck to confirm nothing broke
5. Report: files modified, approximate lines removed, notable structural changes

Reduction Techniques

Apply in rough priority order. Each change should pass a simple test: "does the code still read clearly to someone seeing it for the first time?"

Delete dead code

• Unreachable branches, unused imports, unused variables, unused functions, unused types
• Feature flags that are always on/off
• Commented-out code — it's in git history if anyone needs it

Strip AI-generated noise

• Comments explaining obvious code (// increment counter above count++)
• Comments more detailed than surrounding file style
• Section headers/banners (// TYPES ---, // CONSTANTS, // PUBLIC API)
• Keep only comments explaining WHY, not WHAT
• Noisy logs: console.log/logger calls with no actionable information (keep errors, warnings, state transitions, external API calls)

Remove defensive bloat

• try/catch around code that cannot throw
• Null checks on values already guaranteed non-null by the type system or prior logic
• Redundant parameter validation inside internal (non-boundary) functions
• Assertions that duplicate what the type system already enforces
• Exception: keep defensive code at system boundaries (network calls, file I/O, user input, external APIs)

Collapse indirection

• Inline functions/methods called exactly once (unless the name provides significant documentation value)
• Inline single-use variables: const x = foo(); return x; → return foo();
• Flatten unnecessary wrappers: const handleClick = () => doThing() → pass doThing directly
• Collapse single-implementation interfaces/abstractions — if there's only one implementation and no test mock, the abstraction isn't paying for itself yet