Show HN: Rev-dep – 20x faster knip.dev alternative build in Go

The Hidden Tax on Every Growing Software Team

Every software project that survives long enough eventually faces the same quiet crisis: the codebase starts growing faster than the team can understand it. Functions nobody calls, exports that were created for a feature that shipped in 2022 and got quietly deprecated, components that live on disk but never reach a browser. This isn't sloppiness — it's physics. Teams move fast, requirements change, and entropy is relentless. The question isn't whether your codebase has dead code. The question is how much it's costing you right now.

According to research from Google's engineering productivity team, developers spend an average of 42% of their coding time reading and understanding existing code rather than writing new functionality. When that existing code includes thousands of lines that no longer serve any purpose, that percentage skews even higher. For a team of ten engineers, that's effectively four full-time employees doing nothing productive — not because they're lazy, but because their tools aren't keeping pace with the velocity at which software ages.

This is why a new wave of developer tooling built on systems languages like Go and Rust is generating real excitement in engineering circles. Tools like Rev-dep — a reverse dependency analyzer that claims to run 20x faster than the popular JavaScript-based knip.dev — represent more than just incremental improvement. They signal a fundamental rethinking of how we instrument the development process itself.

What Reverse Dependency Analysis Actually Does

Before understanding why speed matters so much, it helps to understand what dependency analysis tools are actually doing. In a JavaScript or TypeScript project, every file imports from other files. Every function, class, or constant that gets exported from a module creates a potential dependency — something that other parts of the codebase might rely on. "Reverse" dependency analysis flips this perspective: instead of asking "what does this module depend on," it asks "what depends on this module?"

If the answer to that second question is "nothing," you've found dead code. An export that nothing imports is waste. A function that nothing calls is technical debt with a monthly interest rate. Reverse dependency tools systematically walk your entire project graph, map every relationship between modules, and surface the nodes that have no inbound connections. The result is a precise audit of everything in your codebase that could be safely removed.

Knip.dev does this well for JavaScript and TypeScript projects, and it's widely respected in the community. But it's written in JavaScript, which means it runs on Node.js, which means it inherits all of Node's single-threaded performance constraints when doing large-scale file system traversal and symbol analysis. For a project with 500 files, this is fine. For a project with 50,000 files — the kind of monorepo that powers real enterprise SaaS products — the analysis can take minutes. And minutes, at the cadence modern CI/CD pipelines operate at, is a dealbreaker.

Why Go Changes the Calculation

Go was designed from the ground up for exactly the kind of workload that dependency analysis demands: fast file I/O, excellent concurrency primitives, and minimal runtime overhead. Where Node.js processes one task at a time on a single thread and relies on callbacks and promises to fake parallelism, Go can spawn thousands of goroutines that genuinely execute in parallel across all available CPU cores. For a task that involves reading hundreds of files, parsing their ASTs, and building a graph of symbol relationships, this architectural difference translates directly into wall-clock performance.

The 20x speedup claimed by Rev-dep isn't magic — it's what happens when you match the right language to the right problem. Go's compiled nature also means no JIT warmup penalty. From cold start to complete analysis, a Go binary is operating at near-peak performance. The practical implication is that analysis that took 90 seconds in a Node-based tool can complete in under 5 seconds in a well-implemented Go equivalent. That's the difference between a check that developers skip because it "takes forever" and one that runs on every commit without anyone noticing the overhead.

"The best developer tool is one that gets out of the way. If your analysis suite adds three minutes to every CI pipeline, developers will find ways to skip it. Speed isn't a nice-to-have — it's the prerequisite for adoption."

The Business Case for Codebase Hygiene

Dead code isn't just a developer aesthetics problem — it has concrete business consequences that compound over time. Consider what bloated codebases actually cost organizations:

• Longer build times that slow down deployment pipelines and reduce the number of releases a team can safely ship per week
• Higher cognitive load for onboarding engineers, who must spend weeks distinguishing active patterns from abandoned ones
• Increased bundle sizes that hurt application performance, particularly in web apps where every kilobyte affects load times and conversion rates
• Security surface expansion — dead code that still contains dependencies is still a vector for vulnerabilities in those packages
• Test suite bloat where tests for removed functionality continue to run, consume CI minutes, and occasionally fail in confusing ways
• False complexity signals that make architectural decisions harder because it's unclear what's load-bearing and what's vestigial

A 2023 study by the DevOps Research and Assessment (DORA) group found that teams with strong code quality practices — including regular dead code removal — shipped 2.4x more frequently and had 7x lower change failure rates than teams that let technical debt accumulate. The correlation isn't coincidental. Clean codebases are easier to reason about, easier to test, and easier to change safely.

For businesses building on platforms like Mewayz — which powers 138,000 users across 207 distinct business modules ranging from CRM and payroll to fleet management and link-in-bio tools — codebase health has multiplied stakes. When your platform spans that many functional domains, the integration surface between modules is enormous. Unused exports in a core module can create false expectations for dependent modules, trigger unnecessary re-renders in the UI layer, and complicate the dependency graph in ways that make future changes risky.

Integrating Dependency Analysis Into Modern Development Workflows

The real power of fast tooling like Rev-dep isn't the one-time cleanup it enables — it's the ability to run continuous analysis as part of your normal development cycle. When a dead code scan takes 4 seconds instead of 4 minutes, you can add it to your pre-commit hooks. When it takes 4 seconds instead of 4 minutes, your CI pipeline can fail a pull request that introduces new unused exports rather than letting them accumulate silently.

This shift from "quarterly cleanup event" to "continuous quality gate" is analogous to what happened when linters became fast enough to run on every keystroke in an IDE. Before ESLint ran in real-time, code style was enforced by periodic code reviews. After, it became ambient — part of the feedback loop developers experienced while writing code, not after. Fast dependency analysis can create the same ambient quality pressure around dead code.

Setting up this workflow typically involves three components:

1. Baseline analysis: Run the tool against your current codebase to understand the scale of existing dead code. Don't try to fix everything at once — triage by module and prioritize by risk.
2. CI enforcement: Add the analysis to your pipeline with a threshold — fail on any newly introduced unused exports, but don't fail on existing ones until you've cleaned them up.
3. Scheduled cleanup sprints: Use the tool's output to guide regular cleanup work, tracking dead code count as a team health metric over time.

What the Go Tooling Renaissance Signals for SaaS Builders

Rev-dep is part of a broader pattern in developer tooling: high-performance alternatives to established JavaScript tools, built in Go or Rust, are appearing across every category. Biome replaced ESLint and Prettier for many teams. Turbopack and Rspack are eating Webpack's lunch. Bun is challenging Node.js itself. The common thread is that these tools don't just offer incremental improvement — they offer step-function improvements that change what's practical.

For SaaS companies building complex, multi-module products, this tooling renaissance has direct implications for engineering velocity. Mewayz's 207-module architecture — spanning everything from HR and payroll to booking systems and analytics dashboards — represents exactly the kind of large, interconnected codebase where fast, accurate dependency analysis becomes operationally critical. When a change to a shared utility module could theoretically ripple through dozens of feature modules, having near-instant visibility into the actual dependency graph isn't just convenient — it's the kind of infrastructure that prevents expensive production incidents.

The ability to answer "what actually uses this function" in under five seconds rather than five minutes changes how engineers make decisions. It lowers the cost of investigation, which means engineers investigate more often, which means they make better decisions. This is the compounding return on investment in fast tooling that often gets overlooked when organizations think about developer productivity spending.

Making Dead Code Elimination Part of Your Engineering Culture

Technology alone doesn't build clean codebases — culture does. Tools like Rev-dep provide the capability, but turning that capability into consistent practice requires organizational commitment. The most effective teams treat dead code metrics the same way they treat test coverage: as a visible, tracked indicator of codebase health that gets reviewed in engineering meetings and factored into sprint planning.

Some specific cultural practices that work well include designating "code deletion days" — periodic events where the explicit goal is to remove code rather than add it. Netlify famously gamified this by running leaderboards tracking net lines deleted. Stripe has written publicly about their practice of treating code deletion as a first-class engineering contribution, equal in value to feature work. The mindset shift required is recognizing that the best code is code that doesn't exist: every line you don't write is a line you never have to maintain, test, debug, or explain to a new hire.

For product companies managing complex business operations, the parallel outside of engineering is equally instructive. The same discipline that makes codebases healthier — regular audits, clear ownership, elimination of things nobody uses — makes business processes healthier too. Platforms like Mewayz are built precisely to give businesses that kind of operational clarity: a unified view of which tools are being used, which workflows are generating value, and where organizational dead weight is accumulating. Whether you're auditing unused software exports or unused business processes, the underlying discipline is identical.

The tools are getting faster, the feedback loops are getting tighter, and the teams that invest in codebase hygiene infrastructure today are building a compounding advantage that will pay dividends for years. Rev-dep and its cohort of Go-powered developer tools aren't just interesting benchmarks — they're the infrastructure layer that makes sustainable software velocity possible. And in a world where speed of iteration is the primary competitive advantage for software businesses, that's not a peripheral concern. It's the whole game.

Frequently Asked Questions

What makes Rev-dep faster than knip.dev?

Rev-dep is built in Go, a compiled systems language optimized for concurrency and raw execution speed, whereas knip.dev runs on Node.js. This architectural difference allows Rev-dep to analyze dependency graphs and detect dead code up to 20x faster. For large monorepos or complex codebases — like the 207-module architecture powering Mewayz's business OS at app.mewayz.com — that performance gap translates into real time saved on every CI run.

How much dead code does a typical growing project accumulate?

Studies and anecdotal reports from engineering teams suggest that mature codebases can carry anywhere from 10% to 35% unused or unreachable code. The problem compounds as teams scale — features get deprecated, APIs change, and modules are abandoned without cleanup. Platforms like Mewayz, which consolidates over 207 business modules into a single $19/mo operating system, rely heavily on systematic dead code detection to keep the codebase lean and maintainable.

Is Rev-dep suitable for teams that don't use JavaScript or TypeScript?

Rev-dep is currently focused on JavaScript and TypeScript ecosystems, making it a direct alternative to knip.dev for those environments. Support for additional languages may expand as the project matures. If your team builds web-based products or SaaS tools — similar to how Mewayz delivers its full business OS at app.mewayz.com — and your stack is JS/TS-heavy, Rev-dep is well worth evaluating as part of your developer toolchain today.

Can I integrate Rev-dep into my existing CI/CD pipeline?

Yes. Rev-dep is designed as a CLI tool, making it straightforward to drop into any CI/CD pipeline alongside your existing linting and testing steps. Its speed advantage is especially valuable in automated pipelines where faster feedback loops reduce developer wait times. Whether you're running a lean startup or managing a full-featured platform like Mewayz's $19/mo business OS, integrating dead code analysis into your pipeline helps enforce codebase hygiene at every merge.