Introduction
Scrubby is a codebase intelligence layer that gives every AI agent — and every pull request — context about how your team actually builds software.
Scrubby is a codebase intelligence layer. It learns the architectural domains in your repository, the conventions your team uses inside each one, and the patterns of how files actually change together over time. It then makes that knowledge available in two places where decisions get made about your code:
- Inside your AI editor — Claude Code, Cursor, Windsurf, VS Code, or Zed — through a Model Context Protocol (MCP) server. Your agent can query Scrubby for the conventions in a domain, the blast radius of a change, or the files that historically move with the one it’s editing — and incorporate that context into the code it generates.
- On every pull request, through a GitHub App. When a PR opens, Scrubby reviews the changeset against your codebase’s actual patterns and posts findings inline.
The two channels aren’t redundant. The MCP server keeps bad code from being written in the first place. The GitHub App catches anything that slips through and posts a review grounded in your team’s history.
Who Scrubby is for
- Developers writing code with AI agents who keep rewriting suggestions because they almost-fit-but-not-quite.
- Engineering leaders trying to convert individual AI velocity gains into team-level throughput.
- CTOs and VPs of Engineering trying to put a real number on AI ROI and reduce the risk profile of AI-generated code.
- Open source maintainers drowning in drive-by AI-generated PRs.
If you’re not sure where you fit, the Quickstart is the fastest way to feel the difference.
What Scrubby is not
It’s also not a generalist AI code reviewer. The goal isn’t “smart comments on a diff” — it’s grounded review tied to your repo’s history.
The three layers of codebase intelligence
Every Scrubby review and every MCP tool call draws from three layers, built automatically on the first index and refined as your code evolves.
| Layer | What Scrubby learns | Where it shows up |
|---|---|---|
| Domains | The architectural regions of your codebase — “Authentication”, “Billing”, “Background Jobs” — and which files belong to each. | Domain-aware review on every PR; MCP query scrubby_get_domains. |
| Conventions | The patterns your team actually uses inside each domain — naming, file structure, error handling, test layout — mined from real code. | Convention violations flagged on PRs; MCP query scrubby_review returns the conventions for a file. |
| Co-change & connections | Which domains and files historically change together, weighted by how reliable the pairing is. | Missing-co-change warnings on PRs; MCP query scrubby_get_network shows the blast radius. |
Each layer is described in detail in Concepts.
What’s in these docs
- Get Started — sign up, install, connect a repo, run your first review.
- Concepts — how Scrubby thinks about your codebase, with no commands.
- Integrations — setup pages for the GitHub App and every supported editor.
- Guides — task-oriented “how do I…” pages.
- Reference — complete MCP tool list, REST API, webhook payloads, error codes, rate limits, glossary.
- Troubleshooting — symptom-led pages for the most common breakages.
Where to go next
If you want to feel what Scrubby does, jump to the Quickstart. If you want to understand the system before you wire it up, start with How Scrubby Works.
Last updated