> ## Documentation Index
> Fetch the complete documentation index at: https://docs.fallow.tools/llms.txt
> Use this file to discover all available pages before exploring further.

# Quick start

> Run Fallow for the first time and understand the output in under a minute. One golden path, then branch into VS Code, CI, MCP, or runtime intelligence.

This page gets you from zero to a useful result fast. Everyone starts the same way. Branch off at the end.

## 1. Run Fallow

From your project root:

```bash theme={null}
npx fallow
```

That runs three analyses in one pass:

* **Dead code**: unused files, exports, dependencies, cycles, boundaries, and more
* **Duplication**: repeated logic across files
* **Health**: complexity hotspots and refactor targets

<Tip>
  95 built-in plugins cover Next.js, Vite, Jest, Tailwind, PandaCSS, tap, tsd, and more. No configuration needed for the first run.
</Tip>

## 2. Run the focused commands you'll use most

```bash theme={null}
npx fallow dead-code          # Cleanup candidates
npx fallow dupes              # Repeated logic
npx fallow health             # Complexity and refactor targets
npx fallow fix --dry-run      # Preview automatic cleanup
```

## 3. Understand the output

### Dead code

Use this when you want cleanup candidates.

```bash theme={null}
npx fallow dead-code
```

Reports unused files, exports, types, dependencies, circular deps, and boundary violations. See the [dead code guide](/analysis/dead-code).

### Duplication

Use this when repeated logic is spreading.

```bash theme={null}
npx fallow dupes
```

Default `mild` mode catches AST-based duplicates. Add `--mode semantic` to also catch clones with renamed variables. See the [duplication guide](/analysis/duplication).

### Health

Use this when you want to prioritize refactors.

```bash theme={null}
npx fallow health
```

Reports complexity findings, per-file maintainability, hotspots, and ranked refactor targets. See the [health explanation](/explanations/health).

### Fix preview

Use this before deleting anything automatically.

```bash theme={null}
npx fallow fix --dry-run
```

When you're ready, drop `--dry-run`. See the [auto-fix guide](/analysis/auto-fix).

## 4. Pick your next step

<Info>
  Existing repo with backlog? Read [Adopt Fallow in an existing repo](/adoption) for a structured cleanup path, then come back here to wire up CI or VS Code.
</Info>

<CardGroup cols={2}>
  <Card title="Use it in VS Code" icon="window" href="/integrations/vscode">
    Real-time diagnostics, Code Lens above exports, and one-click fixes.
  </Card>

  <Card title="Use it in CI" icon="shield-check" href="/integrations/ci">
    Turn Fallow into a PR and merge gate with SARIF or MR annotations.
  </Card>

  <Card title="Use it from agents" icon="robot" href="/integrations/mcp">
    Add MCP for structured tool calling from Claude Code, Cursor, and more.
  </Card>

  <Card title="Add runtime evidence" icon="chart-network" href="/analysis/runtime-coverage">
    Layer production execution data into `fallow health`.
  </Card>
</CardGroup>

## Optional: create a config

Fallow works without a config file. When you want to customize, run:

```bash theme={null}
fallow init
```

This auto-detects your project structure and generates a tailored config. It also adds `.fallow/` to your `.gitignore`.

<CodeGroup>
  ```jsonc .fallowrc.json theme={null}
  {
    "$schema": "https://raw.githubusercontent.com/fallow-rs/fallow/main/schema.json",
    "entry": ["src/workers/*.ts", "scripts/*.ts"],
    "ignorePatterns": ["**/*.generated.ts"],
    "rules": {
      "unused-files": "error",
      "unused-exports": "warn",
      "unused-types": "off"
    }
  }
  ```

  ```toml fallow.toml theme={null}
  entry = ["src/workers/*.ts", "scripts/*.ts"]
  ignorePatterns = ["**/*.generated.ts"]

  [rules]
  unused-files = "error"
  unused-exports = "warn"
  unused-types = "off"
  ```
</CodeGroup>

<Info>
  Migrating from knip or jscpd? Run `fallow migrate`, or see the [knip](/migration/from-knip) or [jscpd](/migration/from-jscpd) guides.
</Info>

## Optional: runtime intelligence

Fallow's static layer is free and open source. If you want to know what actually executed in production, add the runtime layer:

```bash theme={null}
npx fallow license activate --trial --email you@company.com
npx fallow coverage setup
npx fallow health --runtime-coverage ./coverage
```

Before you do that, read [Static vs runtime intelligence](/explanations/static-vs-runtime) for the mental model, then the [runtime coverage guide](/analysis/runtime-coverage) for setup details.

## Optional: workflow-specific setup

### Agents

Any agent that can run a shell command can use Fallow. Use `--format json` for structured output:

```bash theme={null}
npx fallow --format json
npx fallow dead-code --format json
npx fallow fix --dry-run --format json
```

If your agent supports MCP, add structured tool calling:

```json theme={null}
{
  "mcpServers": {
    "fallow": {
      "command": "fallow-mcp"
    }
  }
}
```

See the [MCP integration guide](/integrations/mcp).

### Humans

Install the VS Code extension for real-time diagnostics, Code Lens above exports, and one-click fixes:

```bash theme={null}
code --install-extension fallow-rs.fallow-vscode
```

See the [VS Code integration guide](/integrations/vscode).

### CI

Use the GitHub Action, the GitLab template, or `npx fallow --ci` on any CI:

<Tabs>
  <Tab title="GitHub Action">
    ```yaml theme={null}
    - uses: fallow-rs/fallow@v2
      with:
        format: sarif
    ```
  </Tab>

  <Tab title="GitLab CI">
    ```yaml theme={null}
    include:
      - remote: 'https://raw.githubusercontent.com/fallow-rs/fallow/main/ci/gitlab-ci.yml'

    fallow:
      extends: .fallow
    ```
  </Tab>

  <Tab title="Other CI">
    ```yaml theme={null}
    - run: npx fallow --ci
    ```
  </Tab>
</Tabs>

See the [CI integration guide](/integrations/ci).

## Next steps

<CardGroup cols={2}>
  <Card title="Analysis overview" icon="magnifying-glass" href="/analysis/index">
    What Fallow analyzes, at a glance.
  </Card>

  <Card title="Configuration" icon="gear" href="/configuration/overview">
    Customize entry points, rules, and ignore patterns.
  </Card>

  <Card title="Explanations" icon="book-open" href="/explanations/index">
    Mental models for how Fallow works.
  </Card>

  <Card title="CLI reference" icon="terminal" href="/cli/dead-code">
    Every command and flag.
  </Card>
</CardGroup>