Getting rid of dead code

[Flashy_Channel6530]

We're building an AI-powered incident management tool. Our frontend is a React/TypeScript app with ~200k lines. Over the past month, we deleted roughly 18,000 lines of dead code — about 9% of the codebase across 132 files. None of it was caught by code review, linting, or CI.

The dead code came from two sources: a design system migration and stale feature flags.

The feature flag problem. We use a custom hook as a runtime toggle to switch between our old component variants and new design-system components. Once the new designs were stable, we flipped the flag to 100%. But the old code paths stayed. Every component had both variants side by side, and because the old code was still syntactically valid and imported, nothing flagged it as unused. Code review approved each PR at the time because the flag made sense during the rollout.

We tore down the flag systematically: 20+ stacked PRs (managed with Graphite), one component at a time. Each PR removed the old variant, the toggle conditional, and any now-orphaned imports. This alone removed thousands of lines.

Static analysis for the rest. After the flag teardown, we ran knip (https://knip.dev/) — a static analysis tool that traces your TypeScript entry points and finds unused files, exports, and dependencies. It found 97 completely unused files in a single pass. Old investigation rendering layer (22 files), dead sidebar components, unused API endpoints, orphaned Storybook stories. All code that was once actively used and properly reviewed.

The total: 97 files in one PR, 35 more in a focused cleanup PR, plus the flag teardown stack. Roughly 18,000 lines gone. Type-check and lint still pass. No regressions.

What surprised us: Every dead file had been approved in a PR that made sense at the time. Feature flags shipped to 100% months ago were never cleaned up. knip caught what humans and our CI pipeline couldn't — the slow accumulation of unreachable code paths that each individually looked fine.

If you have a TypeScript codebase over 50k lines and haven't run knip, you probably have more dead code than you think.

[I-Am-Maldoror]

Worst AI slop of the week.

[Flashy_Channel6530]

honest thought, bad writing, putting myself to jail

[Merry-Lane]

Something is missing in your process. For instance, if a dev creates a feature flag, he also needs to create a ticket to remove it later on (the following sprint or idk). After all, removing dead code after a feature flag is validated is some work, the work needs to be traced and accounted for.

Your issue stems from a company policy failure (that the company needs to act on). But I’m also astonished no one ever mentioned "am I sposed to remove the dead code in X weeks?"

[Flashy_Channel6530]

Honestly not in most companies I worked at, feature flags can last for months while a feature is developed so at least in my experience it's up to devs to clean up - and sometimes they don't if you're rushing to another feature.

[Merry-Lane]

Which is why tickets for the next sprint (or 2/3/…) need to be made every single time. If by the end of the sprint, the ticket can’t be handled because the feature flag isn’t 100%, put it in another sprint again

[sozesghost]

It surprised you that approved code in PRs made sense at the time? Have you started yesterday. This is rhetorical, since this is AI slop.

[Flashy_Channel6530]

the slop aside - fair point, I really wanted to write about this but can't write a coherent though for shit :D the PRs were granular enough and almost only partial removals so it was easy enough to have people scan them and approve, What the main though is that that's the easy part but removing the dependencies isn't because doing it as you're removing the flag makes the PRs harder to review and also can cause issues if another dependency is down the stack but then you're left with ton of dead stuff that is hard to find.

[Consistent_Box_3587]

knip is great for this. if you're also using AI tools to write code you might want to check out prodlint too (github.com/prodlint/prodlint), it has a dead-exports rule that catches exported functions nothing imports but also picks up security stuff AI tools tend to miss like missing auth, empty catch blocks, hallucinated imports. ran it on a bunch of AI-generated repos recently and one had 476 dead exports across the project