Skip to main content
npx fallow              # Run all analyses. Zero config, sub-second
npx fallow dead-code    # Dead code & circular deps only
npx fallow dupes        # Code duplication
npx fallow health       # Complexity hotspots & codebase health
npx fallow flags        # Feature flag detection
npx fallow fix          # Auto-remove unused exports & deps
$ fallow
── Dead Code ──────────────────────────────────────
● Unused files (16)
src/server/jobs/worker.ts
src/server/jobs/cron.ts
src/features/savings/hooks/usePotGroups.ts
… and 13 more

● Unused exports (20)
src/components/Card/index.ts
:1 CardFooter
src/providers/trpc-provider/index.tsx
:12 TRPCProvider

● Unused dependencies (1)
@trpc/react-query

── Duplication ────────────────────────────────────
● Clone groups (8) 2.1% duplication
src/features/tax/utils.ts:14-38
↔ src/features/savings/utils.ts:22-46 (25 lines, 92 tokens)
… and 7 more groups

── Complexity ─────────────────────────────────────
● High complexity (5)
src/server/router.ts:42 handleRequest cyclomatic: 28, cognitive: 34
src/features/tax/calculator.ts:15 computeTax cyclomatic: 22, cognitive: 19
… and 3 more

✗ Found 50 issues across 3 analyses in 0.21s

​
Why fallow?

Linters enforce style. Formatters enforce consistency. Fallow enforces relevance. AI writes code. Nobody deletes it. Every file added by an agent, every export left after a refactor, every boundary your architecture agreed to enforce — it accumulates. Linters work file by file. TypeScript works type by type. Neither builds the full , so neither can see what nothing depends on. Fallow does. One pass covers unused code, circular dependencies, architecture boundary violations, duplicated logic, and complexity hotspots. Rust-native, deterministic, zero configuration. Most projects finish in under a second. Run it today.

​
Three tracks, one tool

Agents

Any agent that can run a shell command can use fallow. fallow --format json gives structured results for all analyses. MCP server available for typed tool calling. Agents generate the code, fallow tells them what’s unused, circular, duplicated, or overly complex.

Humans

Real-time diagnostics in VS Code. Code Lens above every export. One-click fixes. The CLI for power users. Instant feedback as you code.

CI

The safety net. GitHub Actions with SARIF upload, baseline comparison for incremental adoption, PR-scoped analysis with --changed-since. Dead code, circular deps, duplication: nothing lands in main without passing fallow.

Deterministic

Every result is traceable to a concrete import graph path. No probabilistic guessing, no missed files. If fallow says it’s unused, you can verify exactly why.

Sub-second

Rust-native with Oxc parser and rayon parallelism. Analyzes 3,000+ file monorepos in ~300ms. Scales to 20,000+ file projects without memory issues. Linear memory usage, no garbage collection pauses. Fast enough for watch mode, agent loops, and tight CI.

Zero config

90 built-in plugins auto-detect Next.js, Vite, Jest, Tailwind, and more. Works out of the box. No setup, no config files, just run it.

​
Speed comparison

ProjectFilesfallowknip v5knip v6vs v5vs v6
zod17417ms577ms300ms34x18x
fastify28619ms791ms232ms41x12x
preact24420ms767ms2.02s39x103x
TanStack/query901170ms2.50s1.28s15x8x
svelte3,337359ms1.73s749ms5x2x
next.js20,4161.66sn/a‡n/a‡n/an/a
Benchmarked on 6 real-world open-source projects from 174 to 20,416 files. 5-41x faster than knip v5, 2-18x faster than knip v6. On the largest monorepos, knip errors out and fallow is the only tool that completes. ‡ knip errors out without producing valid results.

​
What it finds

Dead code

15 issue types: unused files, exports, types, dependencies, enum members, class members (with inheritance and decorator awareness), circular dependencies, boundary violations, and more.

Circular dependencies

Detects dependency cycles in the module graph that cause initialization bugs, bundler issues, and make refactoring dangerous.

Code duplication

4 detection modes from exact matches to semantic clones with renamed variables. Clone families with refactoring suggestions.

Complexity hotspots

Finds the most complex functions, per-file maintainability scores, git-churn hotspots, and ranked refactoring targets.

Auto-fix

Remove unused exports and dependencies automatically. Agents can run fallow fix --yes from CLI or call fix_apply via MCP. Humans preview with --dry-run.

CSS and SCSS accuracy

AST-based extraction for SCSS partials, @use/@forward, Tailwind directives, and CSS Module class tracking. No regex, no false positives on CSS imports.

Structured output

JSON, SARIF, and markdown output for programmatic use. Agents parse JSON directly. CI uploads SARIF to GitHub Code Scanning. Markdown for PR comments. Compact format for grep and scripting.

​
Get started

Agents can run fallow directly from the command line. No MCP required:
npx fallow --format json                # All analyses
npx fallow dead-code --format json      # Dead code only
npx fallow dupes --format json          # Duplication only
npx fallow health --format json         # Complexity hotspots
npx fallow fix --dry-run --format json  # Preview auto-fixes
For structured tool calling via MCP, add to your agent’s config:
{
  "mcpServers": {
    "fallow": {
      "command": "fallow-mcp"
    }
  }
}
Your agent can now call analyze, check_changed, find_dupes, check_health, fix_preview, fix_apply, and project_info as structured tools. Full agent integration guide

Installation

npm, cargo, or binary download.

Quick Start

Full walkthrough in 2 minutes.

Configuration

Customize for your project.