# repowise > repowise is an open-source (AGPL-3.0) codebase intelligence platform that indexes any repository once and serves both AI coding agents and the humans accountable for the code. For agents, it provides a queryable architecture wiki, dependency graph, git intelligence, architectural decisions, and nine MCP tools for Claude Code, Cursor, Cline, and Codex. For teams, it provides a defect-validated code-health score (cross-project ROC AUC 0.74 across 21 repos and 9 languages), change-risk analysis, dead code detection, and agent provenance tracking. The core engine is free, self-hosted, and requires no cloud account. ## Product - [Homepage](https://repowise.dev/): What repowise is, who it serves, and the one-command install - [Pricing](https://repowise.dev/pricing): Free (public repos), Pro, Teams, Enterprise - [Architecture](https://repowise.dev/architecture): How the indexing pipeline, graph, and intelligence layers fit together - [Explore](https://repowise.dev/explore): Live indexed repositories to browse repowise output on real codebases - [Bot](https://repowise.dev/bot): The GitHub PR bot that posts deterministic code-health comments on every pull request ## Features - [Code health](https://repowise.dev/features/code-health): A defect-validated 1 to 10 score per file. Zero LLM. - [Agent provenance](https://repowise.dev/features/agent-provenance): See how much of your code AI wrote, and whether it is healthy. - [AI context (MCP)](https://repowise.dev/features/ai-context): Nine MCP tools that give your agent real codebase context. - [Change risk](https://repowise.dev/features/change-risk): A 0 to 10 defect-risk score for any commit or PR. - [Security](https://repowise.dev/features/security): Reachability-aware CVE triage on your dependency graph. - [Auto wiki](https://repowise.dev/features/wiki): A documented wiki of your codebase that rebuilds itself. - [Git intelligence](https://repowise.dev/features/git-intelligence): Hotspots, ownership, hidden coupling, and bus factor. - [Architecture (C4)](https://repowise.dev/features/architecture): C4 system context, containers, and components. - [Decisions](https://repowise.dev/features/decisions): Architectural decisions mined from eight sources. ## Solutions - [For developers](https://repowise.dev/for/developers): Give Claude Code, Cursor, and any MCP client a queryable model of your repo. - [For teams](https://repowise.dev/for/teams): One shared index, one credit pool, one org install. The whole team on the same brain. - [For team leads](https://repowise.dev/for/team-leads): Flag the risky PRs, the hotspots, and the hidden coupling, on every pull request. - [For engineering leaders](https://repowise.dev/for/engineering-leaders): See how much of your code AI wrote, whether it is healthy, and who owns it. - [For security](https://repowise.dev/for/security): CVE triage that knows whether you actually call the vulnerable code. - [For enterprise](https://repowise.dev/for/enterprise): Self-hosted, air-gapped, and commercially licensed for the whole org. ## Comparisons - [All comparisons](https://repowise.dev/compare): How repowise compares to the field - [repowise vs CodeScene](https://repowise.dev/compare/codescene-alternative): Open-source, defect-validated code health, plus the wiki, decisions, and agent context CodeScene does not ship. - [repowise vs DeepWiki](https://repowise.dev/compare/deepwiki-alternative): A self-hostable wiki for your private repos, with code health and git risk layered on top. - [repowise vs Sourcegraph](https://repowise.dev/compare/sourcegraph-alternative): Enterprise-grade agent context without the enterprise contract. Open and self-hostable. - [repowise vs Cursor](https://repowise.dev/compare/cursor-alternative): A durable, cross-agent context layer that outlasts your editor's ephemeral index. - [repowise vs GitClear](https://repowise.dev/compare/gitclear-alternative): See how much of your code AI wrote, tied to health and ownership, not just industry trends. - [repowise vs SonarQube](https://repowise.dev/compare/sonarqube-alternative): Reproducible defect validation and a full intelligence layer, open source and self-hostable, not just pass/fail quality gates. - [repowise vs Snyk Code](https://repowise.dev/compare/snyk-code-alternative): Code-health intelligence that complements a vuln scanner: defect risk, maintainability, and performance Snyk does not score. - [repowise vs Codacy](https://repowise.dev/compare/codacy-alternative): Defect-validated, agent-native, and open source, with architectural decisions and a wiki beyond quality-gate dashboards. - [repowise vs Code Climate / qlty](https://repowise.dev/compare/codeclimate-qlty-alternative): The validated single health score and churn-by-complexity map Code Climate pioneered and left behind, still maintained. - [repowise vs Qodo](https://repowise.dev/compare/qodo-alternative): Deterministic, no-LLM code health plus decisions and a durable index any agent can call, not a closed LLM review bot. - [repowise vs Greptile](https://repowise.dev/compare/greptile-alternative): An exported, human-browsable codebase graph with a wiki and decisions, not an internal index that only feeds PR review. - [repowise vs Swimm](https://repowise.dev/compare/swimm-alternative): Living documentation that stays in sync automatically, the lane Swimm vacated for agentic modernization. - [repowise vs CodeRabbit](https://repowise.dev/compare/coderabbit-alternative): Validated code health you can reproduce, not a raw count of issues found, plus a durable index and decisions. ## Guides - [Code Health: The Complete Guide to Defect-Validated Code Quality](https://repowise.dev/guides/code-health): How repowise scores every file from 1 to 10 with 25 deterministic markers, why the score predicts real bugs, and how to turn it into a ranked worklist you act on the same day. - [AI Context & MCP: How repowise Cuts Agent Context Tokens by 96%](https://repowise.dev/guides/ai-context-mcp): How repowise indexes your repo once and serves it to AI coding agents through nine task-shaped MCP tools that collapse search, read, and reason into a single curated call. - [Git Intelligence: Hotspots, Bus Factor & Hidden Coupling, Explained](https://repowise.dev/guides/git-intelligence): How repowise reads your git history to surface hotspots, bus factor, and hidden co-change coupling — four behavioral signals static analysis can't see, computed deterministically with zero LLM. - [Change Risk & PR Review: Catch the PRs That Break Things Before You Merge](https://repowise.dev/guides/change-risk): How repowise scores change risk and blast radius deterministically from the real dependency graph and git history, then turns it into will_break, missing_cochanges, and missing_tests directives you act on before merge. - [Architecture & Dependency Graph: The Complete Guide to Diagrams Derived From Code](https://repowise.dev/guides/architecture): How repowise parses your repo into one directed dependency graph across 15 languages, ranks it with centrality, and derives browsable C4 and knowledge-graph views with no LLM in the layout path. - [Auto-Wiki & CLAUDE.md: Documentation That Stays in Sync With Every Commit](https://repowise.dev/guides/auto-wiki): How repowise writes a documentation page for every module and file, regenerates only the pages a commit touches, and generates CLAUDE.md and AGENTS.md from the same index — so your docs and your agents stay current with HEAD. - [Decisions & ADRs: Capture the Why Your Code Was Shaped This Way](https://repowise.dev/guides/decisions-adr): How repowise mines architecture decisions from eight sources, backs each with evidence spans, links them to the dependency graph, ages them as the code changes, and serves the rationale over MCP via get_why. - [Agent Provenance: The AI-Debt Radar for AI-Written Code](https://repowise.dev/guides/agent-provenance): How repowise attributes commits to the AI agents that wrote them and fuses that with a defect-validated health score and bus-factor ownership to rank the AI-written code most likely to break. - [Security: Reachability-Aware CVE Triage, Not a Vulnerability Scanner](https://repowise.dev/guides/security): How repowise adds reachability-aware CVE triage, full-history secret detection, and in-review security signals on top of its dependency graph, and where Snyk and SAST stay the right tool. ## Documentation - [Auto-sync](https://docs.repowise.dev/auto-sync): Five ways to keep your repowise wiki current as code changes: post-commit hook, file watcher, GitHub webhook, GitLab webhook, and a polling safety net. - [Contributing](https://docs.repowise.dev/contributing): How to contribute to the OSS Repowise repo. - [Dashboard](https://docs.repowise.dev/dashboard): The local web dashboard that reads your .repowise index and answers architecture, health, ownership and history questions without sending anything off your machine. - [Welcome to repowise](https://docs.repowise.dev): Repowise turns any git repository into a queryable knowledge graph that AI coding agents (Claude Code, Cursor, Windsurf, Claude Desktop, VS Code) can reason over through ten MCP tools. Self-hosted or hosted, same engine. - [Licensing](https://docs.repowise.dev/licensing): AGPL for free use; commercial licensing available. - [Security & data handling](https://docs.repowise.dev/security): What Repowise processes, what it persists, what leaves your machine under each deployment mode, and how to reduce that to zero. - [Upgrading](https://docs.repowise.dev/upgrading): Upgrade the repowise package, run repowise update, and your existing index keeps working. No reindex in the normal case; a full reindex is only ever recommended, never forced. - [Git worktrees](https://docs.repowise.dev/worktrees): Index a linked git worktree without re-indexing from scratch, by seeding from the base checkout and catching up incrementally. - [Decisions: capture, list, govern](https://docs.repowise.dev/cli/decision): Record architectural decisions so the why survives the team. Mine git history for proposals, confirm or dismiss them, deprecate stale ones, and check decision health. - [Distill: compact command output](https://docs.repowise.dev/cli/distill): Run noisy commands through repowise distill for an errors-first, fully reversible rendering that cuts 60 to 90% of the tokens on tests, builds, git, and searches, with zero error-line loss. - [Code health: health, risk](https://docs.repowise.dev/cli/health): repowise health scores every file from deterministic markers across three signals (defect risk, maintainability, performance); repowise risk scores the defect risk of a commit or diff range. Both are zero-LLM and run in seconds. - [Hooks: auto-sync on commit](https://docs.repowise.dev/cli/hook): Install, check, and remove the post-commit git hook that keeps the repowise wiki current after every commit. - [Indexing: init, update, reindex](https://docs.repowise.dev/cli/indexing): The three commands that build and maintain repowise's intelligence layers. init parses everything from scratch, update is incremental on each commit, reindex rebuilds the vector store without re-running the LLM. - [Other commands](https://docs.repowise.dev/cli/other): One-shot utilities: costs, coverage, dead-code, doctor, export, generate-claude-md, telemetry, login/logout/whoami, augment. - [CLI overview](https://docs.repowise.dev/cli/overview): All `repowise` commands at a glance. - [Query: search, status](https://docs.repowise.dev/cli/query): Ask questions and check sync state from the terminal without involving an editor. - [Server & watch: serve, watch, mcp](https://docs.repowise.dev/cli/server): Run the repowise API and dashboard, auto-update on file save, or expose the MCP server directly to an editor. - [Workspace: multi-repo commands](https://docs.repowise.dev/cli/workspace): Manage repos in a repowise workspace: list, add, remove, scan, and pick the default. - [Set up with your agent](https://docs.repowise.dev/getting-started/for-agents): Hand this page to Claude Code, Cursor, Codex, or any coding agent and it can install repowise, index the repo, and wire up MCP on its own. Includes copy-pasteable prompts, the Claude Code plugin, slash commands, skills, and machine-readable docs endpoints. - [How it works](https://docs.repowise.dev/getting-started/how-it-works): The five intelligence layers Repowise computes and how they fit together. - [Agent plugins](https://docs.repowise.dev/getting-started/plugins): The Claude Code and Codex plugins bundle the MCP server, lifecycle hooks, skills, and slash commands into one install. What each plugin ships, how to install it, and what activates when. - [Quickstart](https://docs.repowise.dev/getting-started/quickstart): Install repowise, index your repo, and connect Claude Code in under a minute. Two paths, self-hosted (pip) or hosted (repowise.dev). - [VS Code extension](https://docs.repowise.dev/getting-started/vscode): The Repowise extension brings the local index into VS Code (editor-native health signals, refactoring CodeLens, branch risk, in-editor dashboards) and registers the Repowise MCP server so the same index serves both you and your AI agent. - [What is repowise](https://docs.repowise.dev/getting-started/what-is-repowise): Repowise indexes your codebase into five intelligence layers (graph, git, wiki, decisions, code health) and exposes them to AI agents through ten task-shaped MCP tools. The why your AI agent has been missing. - [Alerts & notifications](https://docs.repowise.dev/hosted/alerts): HMAC-signed Slack-compatible webhooks, the in-product notification bell, and per-kind email preferences, for security events and engineering signals, designed to never spam. - [PR review bot](https://docs.repowise.dev/hosted/bot): A deterministic GitHub App that posts one useful comment per pull request: a before-you-merge checklist, a change-map diagram, code-health deltas, hotspots, hidden coupling, dead code, change risk, and an optional merge gate. Zero LLM calls, free for OSS. - [Connecting your IDE](https://docs.repowise.dev/hosted/connecting-ide): Mint an API key on the hosted dashboard and paste a snippet. Claude Code, Cursor, Claude Desktop, VS Code, and Windsurf supported. - [Dashboard tour](https://docs.repowise.dev/hosted/dashboard): What lives behind sign-in at repowise.dev/dashboard: the hosted control plane for your indexed repos, workspaces, MCP keys, billing, and team. - [Jira & Confluence](https://docs.repowise.dev/hosted/integrations): Connect an Atlassian site to link architectural decisions to the Jira tickets that motivated them, and publish your generated wiki to Confluence on a weekly schedule, updated in place and never duplicated. - [Hosted platform](https://docs.repowise.dev/hosted/overview): Everything the managed platform adds on top of the OSS engine: zero-ops indexing, push-sync, AI docs and chat, the security suite, team portfolio intelligence, and alerting, with a plan ladder from free to enterprise. - [Security suite](https://docs.repowise.dev/hosted/security): CVE-aware dependency scanning with usage and reachability triage, secret detection across full git history, SBOM/VEX export, a nightly CVE refresh, compliance reports, and an insert-only audit trail. - [Teams & portfolio intelligence](https://docs.repowise.dev/hosted/teams): Seats with pooled repos and credits, shared workspaces, portfolio health and ownership rollups, and an engineering-leader dashboard fed by nightly drift detection. - [Hosted vs self-hosted](https://docs.repowise.dev/hosted/vs-self-hosted): Both modes ship the same intelligence layers, the same ten MCP tools, and the same dashboard. The differences are about ops, billing, and team features, not about what the agent can do. - [Configuration: config.yaml & ignore files](https://docs.repowise.dev/installation/configuration): The .repowise/ directory, the config.yaml file repowise generates on first init, and how to control which files get indexed with .gitignore, nested .gitignore, .repowiseIgnore, and --exclude. - [Environment variables](https://docs.repowise.dev/installation/env-vars): Provider API keys, embedder overrides, and runtime knobs that configure repowise's behavior at install and index time. - [Install repowise](https://docs.repowise.dev/installation/install): Install the repowise CLI on macOS, Linux, or Windows via pip or uv. Verify, upgrade, switch versions, or uninstall. Every step. - [Language support](https://docs.repowise.dev/installation/languages): 16 languages with AST support and dedicated resolvers, 11 of them at the Full tier, plus per-language framework awareness for Django, FastAPI, Flask, Express, Spring Boot, Rails, Laravel, and more. - [Requirements](https://docs.repowise.dev/installation/requirements): System and toolchain requirements for self-hosted repowise, covering Python, Git, disk, and an LLM provider key. - [Troubleshooting](https://docs.repowise.dev/installation/troubleshooting): Diagnose a broken index with repowise doctor, plus the most common install and indexing problems with their fixes. - [Auto-generated wiki](https://docs.repowise.dev/intelligence/auto-wiki): How repowise writes a documentation page for every module and notable file: incrementally, with citations, with confidence scoring, and refreshed in under 30 seconds per commit. - [Bug-fix history](https://docs.repowise.dev/intelligence/bug-history): Which files and functions have actually been bug-fixed, how often, and how recently, computed from git alone with a fix-shape classifier validated at 98.3% on 240 hand-labelled commits. - [Code health](https://docs.repowise.dev/intelligence/code-health): A 1 to 10 health score for every file from deterministic markers across three signals: defect risk, maintainability, and performance. Zero LLM calls, defect-calibrated weights, validated to out-rank the leading commercial code-health tool at predicting real bugs. - [Dead code](https://docs.repowise.dev/intelligence/dead-code): Files nothing imports, exports nothing uses, and packages nothing depends on, each with a confidence score and the evidence behind it. - [Architectural decisions](https://docs.repowise.dev/intelligence/decisions): First-class decision records linked to the files they govern: captured by hand, mined from git history, or extracted from inline markers. Surfaced to AI agents via get_why so the why survives the team. - [Dependency graph](https://docs.repowise.dev/intelligence/dependency-graph): How repowise builds the two-tier dependency graph (file nodes and symbol nodes) with import resolution, call resolution, heritage extraction, and community detection. - [Deterministic wiki](https://docs.repowise.dev/intelligence/deterministic-wiki): The wiki repowise renders from your code's structure instead of writing it with a model. No API key, no spend, no network, and a full set of pages you can upgrade to model-written prose later. - [Git history & co-changes](https://docs.repowise.dev/intelligence/git-history): Hotspots, ownership, bus factor, and co-change pairs, the signals repowise mines from your last 500 commits that no AST analysis can produce. - [Proactive agent hooks](https://docs.repowise.dev/intelligence/hooks): Lightweight editor hooks that push graph, git, health, and decision context into Claude Code and Codex at the moment the agent needs it: no LLM, no network, fail-silent. This is also how repowise learns from how you actually use it. - [Refactoring intelligence](https://docs.repowise.dev/intelligence/refactoring): A health score tells you a file is in trouble; refactoring intelligence names the specific fix. Five deterministic detectors (Extract Class, Extract Helper, Move Method, Break Cycle, Split File) emit one structured, graph-aware plan per opportunity, ranked by impact and effort. No LLM in the hot path; code generation runs only on demand, on by default and opt-out. - [Test intelligence](https://docs.repowise.dev/intelligence/test-intelligence): Ingest a coverage report and repowise answers two questions your CI cannot: which files are risky and untested, and which tests a given diff actually exercises. - [generate_refactoring_code](https://docs.repowise.dev/mcp/generate-refactoring-code): Turns one structured refactoring plan from get_health(include=["refactoring"]) into generated code and a unified diff, grounded on the plan plus the real source it references. - [get_answer](https://docs.repowise.dev/mcp/get-answer): One-call RAG synthesis over the wiki: it retrieves, gates on confidence, and returns a cited 2-5 sentence answer with fallback file targets. The first tool to call on any code question. - [get_change_risk](https://docs.repowise.dev/mcp/get-change-risk): Pre-merge defect risk for a whole commit or diff range, scored from the shape of the live diff, plus the tests that actually cover the changed lines and whether those files have been bug-fixed before. - [get_context](https://docs.repowise.dev/mcp/get-context): The workhorse tool. Compact, batched context for any set of files, modules, or symbols: docs, ownership, freshness, and optional source/callers/callees/metrics/community in one call. - [get_dead_code](https://docs.repowise.dev/mcp/get-dead-code): Tiered refactor plan for unused code. High/medium/low confidence findings with per-directory rollups, ownership hotspots, and safe-to-delete impact estimates. Pure graph + SQL, no LLM calls. - [get_health](https://docs.repowise.dev/mcp/get-health): Code-health scores and marker findings per file across three signals (defect risk, maintainability, performance), exposed to your agent so it can self-check a change before opening a PR. - [get_overview](https://docs.repowise.dev/mcp/get-overview): Architecture summary, module map, entry points, ownership, hotspots, and community structure for an entire repository: the first call your agent should make on any unfamiliar codebase. - [get_risk](https://docs.repowise.dev/mcp/get-risk): Modification-risk assessment for files before editing, covering hotspot scores, dependents, co-change partners, blast radius, recommended reviewers, test gaps, and security signals. - [get_symbol](https://docs.repowise.dev/mcp/get-symbol): Raw source bytes for one indexed symbol with exact line bounds, cheaper and safer than reading the whole file and counting offsets. The only MCP tool that returns actual source code. - [get_why](https://docs.repowise.dev/mcp/get-why): Architectural-decision archaeology. Search decisions in natural language, anchor them to a file path, or pull the global decision-health dashboard. Falls back to git archaeology when no recorded decisions exist. - [MCP tools: overview](https://docs.repowise.dev/mcp/overview): The small, curated set of MCP tools repowise exposes to Claude Code and any MCP-compatible AI agent. Task-shaped, batched, and built to collapse long tool-call chains into one round-trip. - [search_codebase](https://docs.repowise.dev/mcp/search-codebase): Hybrid code search over repowise's indexes: symbols, file paths, or the wiki, depending on the shape of the query. One tool instead of a fallback to Grep for identifiers. - [Architecture metrics](https://docs.repowise.dev/multi-repo/architecture-metrics): The one evaluative read of the whole system, propagation cost, the cyclic core, per-service roles, and a deterministic 1-10 architecture score. Standard architecture-complexity metrics computed over the system graph, no LLM. - [Cross-repo blast radius](https://docs.repowise.dev/multi-repo/blast-radius): If you change this service, what downstream services and repos break? Blast radius walks the system graph against its edges and returns every reachable service ranked by impact. - [Breaking-change guard](https://docs.repowise.dev/multi-repo/breaking-changes): Did a provider change in a way that actually breaks its consumers? On every workspace update, freshly-extracted contracts are diffed against the previous index and each incompatible change is reported with the exact consumer files it endangers. - [Architecture conformance](https://docs.repowise.dev/multi-repo/conformance): Declare which services may depend on which others, then continuously check the live system graph against those rules. Your team's architecture lint, plus automatic dependency-cycle detection. - [Cross-repo intelligence](https://docs.repowise.dev/multi-repo/cross-repo): What repowise learns from analyzing several repos together. Co-change pairs, API contracts (HTTP / gRPC / topics), and package dependency mapping. Hidden coupling that single-repo tools can't find. - [System graph & map](https://docs.repowise.dev/multi-repo/system-map): The service-granular system graph repowise folds every cross-repo signal into, the Live System Map that renders it, and the extraction diagnostics that explain why a contract link did or didn't form. - [Workspace MCP mode](https://docs.repowise.dev/multi-repo/workspace-mcp): One MCP server, every repo. Pass repo="backend" to target a specific workspace repo, or repo="all" to federate a query across the entire workspace, plus three workspace-only tools for cross-repo blast radius, conformance, and architecture. - [Workspace setup](https://docs.repowise.dev/multi-repo/workspace-setup): Index multiple related git repos as a single repowise workspace. Get cross-repo co-changes, API contract matching, and federated MCP queries on top of per-repo intelligence. - [Benchmarks](https://docs.repowise.dev/reference/benchmarks): Every number repowise publishes, with the method behind it and the limits it carries, across three studies on public codebases. - [Computed glossary](https://docs.repowise.dev/reference/glossary): Every term repowise computes across traversal, graph, git, analysis, generation, workspace, persistence, and MCP. The vocabulary map for wiki pages, graph records, risk signals, contracts, and tool responses. ## Blog: Comparisons - [Best AI Code Review Tools (LLM-Based and Deterministic)](https://repowise.dev/blog/comparisons/best-ai-code-review-tools): Best AI code review tools fall into two camps: LLM-based reviewers that try to reason about intent, architecture, and change impact, and deterministic… - [Best Architecture Documentation Tools (C4, Diagrams, Decisions)](https://repowise.dev/blog/comparisons/best-architecture-documentation-tools): Best architecture documentation tools fall into two camps: tools that model architecture, and tools that keep the model honest. The first group gives you C4… - [Best Code Health Tools in 2026](https://repowise.dev/blog/comparisons/best-code-health-tools-2026): Best code health tools in 2026 are the ones that measure more than static warnings. They show where change is concentrated, where complexity is rising, where… - [Best Code Search Tools for Engineering Teams](https://repowise.dev/blog/comparisons/best-code-search-tools-teams): best code search tools matter when your repo stops being a repo and starts acting like a system. At that point, plain grep is too literal, and “AI search”… - [Best Codebase Documentation Tools for AI Coding Agents](https://repowise.dev/blog/comparisons/best-codebase-documentation-tools-ai-agents): Documentation tools for AI coding agents have changed fast. The old question was “what docs should humans read?” The new one is best codebase documentation… - [Best Codebase Visualization Tools (Graphs, Maps, Diagrams)](https://repowise.dev/blog/comparisons/best-codebase-visualization-tools): The best codebase visualization tools do one job well: they turn a pile of imports, folders, and ownership history into a picture you can act on. That… - [Best Dead Code Detection Tools (Open Source and Commercial)](https://repowise.dev/blog/comparisons/best-dead-code-detection-tools): Best dead code detection tools are only useful if they match the kind of dead code you actually ship. Unreachable files, unused exports, and zombie packages… - [Best Dependency Graph Tools for Monorepos](https://repowise.dev/blog/comparisons/best-dependency-graph-tools-monorepos): best dependency graph tools for monorepos is a narrower question than it looks. Most teams start with a graph that answers build order, then discover they… - [Best Git Analytics Tools (Hotspots, Ownership, Bus Factor)](https://repowise.dev/blog/comparisons/best-git-analytics-tools): Best git analytics tools are the ones that answer three concrete questions fast: where is change concentrated, who understands it, and what breaks if that… - [Best GitHub PR Review Bots in 2026](https://repowise.dev/blog/comparisons/best-github-pr-review-bots-2026): Best GitHub PR bots are not the ones that talk the most. They are the ones that catch real problems, stay out of the way on clean PRs, and keep review… - [Best MCP Servers for Coding Agents](https://repowise.dev/blog/comparisons/best-mcp-servers-coding-agents): best mcp servers for coding agents only matter if they answer a hard question: which server gives an agent the right context with the fewest extra tool… - [Best Open Source Alternatives to CodeScene](https://repowise.dev/blog/comparisons/best-open-source-codescene-alternatives): codescene open source alternatives are a good fit if you want hotspot analysis, ownership signals, and dependency insight without a per-author bill.… - [Best Refactoring Tools and Prioritization Platforms](https://repowise.dev/blog/comparisons/best-refactoring-tools): Best refactoring tools are the ones that tell you what to fix first, not just what looks messy. A codebase full of lint warnings is easy to generate and hard… - [Best Self-Hosted Codebase Documentation Platforms](https://repowise.dev/blog/comparisons/best-self-hosted-codebase-documentation): Best self hosted documentation starts with a simple constraint: your docs have to live where your code lives, and your editors, search, identity, and… - [Best Static Analysis Tools for Large Codebases](https://repowise.dev/blog/comparisons/best-static-analysis-tools-large-codebases): Best static analysis tools for large codebases are not the same thing as the best linters. Linters catch local style and syntax mistakes. Large repos need… - [Best Tools for Test Coverage Analysis (Per-File and Trend)](https://repowise.dev/blog/comparisons/best-test-coverage-tools): best test coverage tools do more than print a single percentage. They tell you which files are drifting, which lines stay dark, and which parts of the… - [Best Tools for Engineering Managers to See Codebase Risk](https://repowise.dev/blog/comparisons/best-tools-engineering-managers-codebase-risk): Engineering manager codebase tools are only useful if they answer three questions fast: where is risk concentrated, who owns it, and what breaks if one… - [Best Tools for Onboarding New Engineers (2026)](https://repowise.dev/blog/comparisons/best-tools-for-onboarding-engineers): Best onboarding tools for engineers are the ones that shorten the time between “I cloned the repo” and “I changed the right file for the right reason.” The… - [Best Tools to Generate CLAUDE.md / AGENTS.md Files](https://repowise.dev/blog/comparisons/best-tools-generate-claude-md-agents-md): The best claude.md generators are the ones that produce useful, repo-specific guidance instead of a wall of generic prose. A good CLAUDE.md or AGENTS.md… - [Best Tools to Understand a Legacy Codebase Fast](https://repowise.dev/blog/comparisons/best-tools-understand-legacy-codebase): A good understand legacy codebase workflow does not start with editing. It starts with reducing unknowns. On day one, the cost is not syntax. It is context:… - [5 Best Codebase Documentation Tools in 2026 (Compared)](https://repowise.dev/blog/comparisons/best-codebase-documentation-tools-2026): For decades, 'good documentation' was the white whale of software engineering. We all knew it was necessary, but the friction of maintaining it—manually upda... - [repowise vs CodeScene: Full Codebase Intelligence Without the Enterprise Price Tag](https://repowise.dev/blog/comparisons/repowise-vs-codescene): CodeScene pioneered hotspot analysis but stops at a dashboard. repowise gives you the same git intelligence open-source, self-hosted, and queryable by AI agents. - [repowise vs DeepWiki: Self-Hosted Codebase Docs That Stay Fresh](https://repowise.dev/blog/comparisons/repowise-vs-deepwiki): Every engineering team eventually hits the 'Documentation Wall.' It's the moment when the codebase grows faster than the human capacity to describe it. You'v... - [repowise vs Google CodeWiki: Why Open Source Wins for Private Codebases](https://repowise.dev/blog/comparisons/repowise-vs-google-codewiki): Every software engineer has experienced the 'onboarding wall.' You join a new team, clone a massive monorepo, and spend the first three weeks essentially pla... - [repowise vs Sourcegraph: Documentation + Intelligence, Not Just Search](https://repowise.dev/blog/comparisons/repowise-vs-sourcegraph): For over a decade, Sourcegraph has been the 'Google for code.' In an era where microservices proliferated and codebases exploded in size, Sourcegraph solved ... ## Blog: Guides - [CLAUDE.md & AGENTS.md: The Complete Guide](https://repowise.dev/blog/guides/claude-md-agents-md-guide): What CLAUDE.md and AGENTS.md are, what to put in them, best practices, and how to keep them fresh automatically. Learn to give coding agents real repo context. - [Code Health: The Complete Guide (2026)](https://repowise.dev/blog/guides/code-health-complete-guide): Code health is a defect-validated measure of how risky code is to change, scored from 25 deterministic markers across three pillars. Reproduce it on your repo. - [Codebase Documentation That Stays Current](https://repowise.dev/blog/guides/codebase-documentation-guide): Living codebase documentation rebuilds on every commit, scores its own freshness, and feeds AI agents. Learn how it works and start with repowise free. - [Git Intelligence: Hotspots, Ownership & Coupling Explained](https://repowise.dev/blog/guides/git-intelligence-guide): Git intelligence reads your git history to surface hotspots, code ownership, bus factor, and change coupling. Learn how the signals work and where to start. - [How to Prioritize Technical Debt (Impact-per-Effort)](https://repowise.dev/blog/guides/prioritize-technical-debt): Prioritize technical debt by impact-per-effort: rank refactoring targets, find dead code, and read coverage as risk. Build your ranked worklist today. - [Spotting Declining Code Health Trends Before They Bite](https://repowise.dev/blog/guides/declining-code-health-trends): Declining code health is usually a slow-burn problem. Teams feel it as “everything takes longer” long before they see a hard failure. The trick is not… - [Hidden Coupling: Finding the Files That Always Change Together](https://repowise.dev/blog/guides/hidden-coupling-co-change-detection): Hidden coupling is the code you do not see in imports. Two files have no direct dependency on paper, yet they still move together every few weeks because… - [Nested Complexity vs Cyclomatic Complexity (and Why It Matters)](https://repowise.dev/blog/guides/nested-vs-cyclomatic-complexity): Nested complexity is the metric people reach for when cyclomatic complexity stops telling the truth. Cyclomatic complexity counts decision paths. Nested… - [Refactoring Priorities: Picking What to Fix First](https://repowise.dev/blog/guides/refactoring-priorities-impact-per-effort): Most teams do not have a refactoring problem. They have a refactoring priorities problem. There is always more code that could be cleaned up than time to… - [Untested Hotspots: The Highest-Leverage Coverage Targets](https://repowise.dev/blog/guides/untested-hotspots-coverage-priority): Untested hotspots are the files most likely to break your product and the least likely to catch it in CI. The signal is simple: high churn, low or zero… - [What Is Code Health? A Practical Guide to the 25 Markers](https://repowise.dev/blog/guides/what-is-code-health-12-biomarkers): What is code health? It is the part of a codebase that tells you whether the system will stay easy to change next week, next month, and next quarter. Code… - [Use git history to catch stale ADRs before they mislead agents](https://repowise.dev/blog/guides/use-git-history-to-catch-stale-adrs-before-they-mislead-agents): Use git history to flag stale decisions in an architecture decision records workflow. Catch drift early with a 500-commit view before agents follow old code. - [Generate a CLAUDE.md from your repo’s ADRs and wiki](https://repowise.dev/blog/guides/generate-a-claude-md-from-your-repos-adrs-and-wiki): Generate claude.md from ADRs and wiki into a day-one agent brief: 1 file, clear rules, and links to the decisions that matter most. - [Generate claude.md from a real repo, not a blank page](https://repowise.dev/blog/guides/generate-claude-md-from-a-real-repo-not-a-blank-page): Generate claude.md from repo architecture, ownership, and recent changes with MCP calls. Give Claude Code a day-one brief that cuts guessing. - [How to Auto-Generate Documentation for Your Codebase with AI](https://repowise.dev/blog/guides/auto-generate-codebase-documentation-ai): Every engineering team starts with a noble intention: 'We will document everything.' It begins with a clean README, a few architecture diagrams in Excalidraw... - [Code Ownership and Bus Factor: Mining Git History for Team Risk](https://repowise.dev/blog/guides/code-ownership-bus-factor-git): Every engineering leader has a 'nightmare scenario': a critical system fails at 3:00 AM, and the only person who understands the underlying logic is unreacha... - [Developer Onboarding Is Broken — Here's How to Fix It with Codebase Intelligence](https://repowise.dev/blog/guides/developer-onboarding-codebase-intelligence): The first week at a new engineering job is often a blur of HR orientation, hardware setup, and the inevitable 'Valley of Despair' that comes with cloning a m... - [How to Find Dead Code in Your Repository (and Why You Should)](https://repowise.dev/blog/guides/find-dead-code-repository): Every codebase is a graveyard of good intentions. In the rush to ship features, we often focus on what to add, rarely on what to remove. Over time, your repo... - [Git Hotspot Analysis: Find the Riskiest Files in Your Codebase](https://repowise.dev/blog/guides/git-hotspot-analysis-risky-files): Every codebase has a 'haunted graveyard'—a module so fragile and convoluted that developers avoid touching it at all costs. These files are often the source ... - [How to Generate a CLAUDE.md File for Your Repository](https://repowise.dev/blog/guides/how-to-generate-claude-md): For years, the `README.md` has served as the primary entry point for human developers. It describes the 'what' and the 'how' of a project, providing just eno... - [Keeping Documentation Fresh: Why Stale Docs Are Worse Than No Docs](https://repowise.dev/blog/guides/keeping-documentation-fresh-stale-docs): In the world of software engineering, there is a pervasive myth that some documentation is always better than no documentation. We treat the README, the inte... - [repowise init: One Command to Index Your Entire Codebase](https://repowise.dev/blog/guides/repowise-init-index-codebase): Every software engineer has experienced the 'Day Zero' friction of a new project: cloning a massive repository, staring at a directory structure with 2,000 f... ## Blog: MCP & AI Agents - [Giving AI Coding Agents Real Codebase Context](https://repowise.dev/blog/mcp/codebase-context-for-ai-agents): Codebase context for AI agents turns one index into 9 task-shaped MCP tools, cutting tokens 96% and stale guesses. See how structured context works — try repowise. - [Claude Code Context Management for Large Codebases](https://repowise.dev/blog/mcp/claude-code-context-large-codebases): Claude Code large codebase work fails for a simple reason: the model can only reason over what fits in its context window. A big repo does not fit. A good… - [Cursor Codebase Context: MCP Setup That Actually Helps](https://repowise.dev/blog/mcp/cursor-mcp-codebase-context): Cursor MCP works best when you stop treating it like a magic search box and start treating it like a source of structured codebase context. Cursor’s own docs… - [What Model Context Protocol actually sends to Claude Code](https://repowise.dev/blog/mcp/what-model-context-protocol-actually-sends-to-claude-code): See how model context protocol sends structured repo data to Claude Code, with a wire-level example and 7 tools to inspect. - [Same refactor, 27× fewer tokens with Repowise MCP](https://repowise.dev/blog/mcp/same-refactor-27x-fewer-tokens-with-repowise-mcp): See how Repowise MCP cut the same refactor to 27× fewer tokens, with transcript and tool-call traces showing the exact savings. - [When an MCP tool should return raw text, not answers](https://repowise.dev/blog/mcp/when-an-mcp-tool-should-return-raw-text-not-answers): A practical mcp tools design rule: return raw evidence when the model needs to inspect files, symbols, or decisions. See the boundary in Repowise. - [Why we ship a graph-aware MCP server instead of file readers](https://repowise.dev/blog/mcp/why-graph-aware-mcp-server-not-file-readers): Graph aware mcp cuts grep loops: resolve callers, dependents, and review impact in one hop. See the token and latency math. - [Task-Shaped MCP Tools Beat Entity CRUD for Code Agents](https://repowise.dev/blog/mcp/task-shaped-mcp-tools-beat-entity-crud-for-code-agents): See mcp tools design on a real regression: task-shaped tools cut re-reading and context loss, with 49% fewer calls and 27× fewer tokens. - [9 MCP Tools That Make AI Agents Actually Useful for Code](https://repowise.dev/blog/mcp/8-mcp-tools-ai-agents-code): The current state of AI-assisted engineering feels like a paradox. We have Large Language Models (LLMs) with massive context windows—some spanning millions o... - [Give Your AI Agent Codebase Context Without Stuffing the Prompt](https://repowise.dev/blog/mcp/ai-agent-codebase-context-without-prompt-stuffing): The engineering community is currently caught in a 'context arms race.' As LLM providers announce increasingly massive context windows—moving from 32k to 200... - [How to Set Up an MCP Server for Claude Code, Cursor, and Cline](https://repowise.dev/blog/mcp/setup-mcp-server-claude-code-cursor-cline): The fundamental bottleneck in AI-assisted engineering isn't the model's reasoning capability; it’s the context window. Even with million-token windows, stuff... - [What Is MCP (Model Context Protocol) and Why Your Codebase Needs a Server](https://repowise.dev/blog/mcp/what-is-mcp-model-context-protocol): We’ve all been there: staring at a 200,000-line repository, trying to explain the intricate dance of a distributed state machine to an LLM. You copy-paste th... ## Blog: Engineering - [Does Code Health Predict Bugs? 21 Repos, 9 Languages, ROC AUC 0.74](https://repowise.dev/blog/engineering/code-health-predicts-bugs-validation-study): A reproducible defect-prediction study: 21 repos, 9 languages, 2,770 labeled files, ROC AUC 0.74, and 2.3x more defects caught under a fixed review budget. - [Is AI-written code buggier than human code? We blamed 112,000 commits to find out](https://repowise.dev/blog/engineering/is-ai-written-code-buggier-than-human-code): We git-blamed 112,382 commits across 28 repos to test whether AI-agent code introduces more bugs than human code. After controlling for size, it doesn't, and its lines last longer. - [Does our code-health score actually predict bugs? A leakage-free benchmark](https://repowise.dev/blog/engineering/does-our-code-health-score-predict-bugs): I scored 21 repos six months before their bugs landed to test whether a deterministic code-health score predicts defects. AUC 0.737, and the honest caveats. - [Process metrics beat structural metrics for predicting defects](https://repowise.dev/blog/engineering/process-metrics-beat-structural-metrics): Complexity and code smells are the metrics everyone reaches for. Across 25 markers and 21 repos, the strongest defect predictors were evolutionary, not structural. The numbers, with file size controlled. - [How a 25-Marker Code Health Scorer Actually Works](https://repowise.dev/blog/engineering/12-biomarker-code-health-scorer-internals): A code health scorer works because one number is only useful if it is built from signals that map to real maintenance cost. A file can look clean and still… - [Building a Deterministic PR Review Bot With Zero LLM Calls](https://repowise.dev/blog/engineering/deterministic-pr-review-bot-no-llm): A deterministic PR review bot can do useful review work without calling an LLM once. That sounds odd until you break “review” into smaller jobs: parse the… - [Why vector-only retrieval misses co-change clusters in monorepos](https://repowise.dev/blog/engineering/why-vector-only-retrieval-misses-co-change-clusters-in-monorepos): Co-change analysis git shows which files move together, who owns them, and what breaks next. See why vector-only retrieval misses refactor signals. - [Our git co-change model failed on a monorepo refactor](https://repowise.dev/blog/engineering/our-git-co-change-model-failed-on-a-monorepo-refactor): Why co-change analysis git overfit a monorepo refactor, and the guardrails we added after 500 commits of history pointed at the wrong coupling. - [The dead-code detector we shipped with Pagerank and git history](https://repowise.dev/blog/engineering/the-dead-code-detector-we-shipped-with-pagerank-and-git-history): Code hotspot detection as ranking, not a linter: Pagerank plus git history sorted quiet files from risky ones, so you can ignore the right 3. - [Architectural Decision Records: Capture Why Your Code Is the Way It Is](https://repowise.dev/blog/engineering/architectural-decision-records-capture-why): Every seasoned engineer has experienced the 'archaeology phase' of a project. You’re looking at a specific abstraction—perhaps a custom implementation of a m... - [Building a Dependency Graph for Any Codebase (Python, TS, Go, Rust, Java)](https://repowise.dev/blog/engineering/building-dependency-graph-any-codebase): Every software engineer has experienced the 'wall of code' phenomenon. You join a new project, clone the repository, and find yourself staring at 100,000 lin... - [How We Built repowise: Architecture of a Codebase Intelligence Platform](https://repowise.dev/blog/engineering/how-we-built-repowise-architecture): Most software engineers spend upwards of 70% of their time reading code rather than writing it. Yet, the tools we use to navigate these complex systems have ... - [Self-Hosting a Codebase Intelligence Platform with Docker](https://repowise.dev/blog/engineering/self-hosting-codebase-intelligence-docker): As engineering teams scale, the primary bottleneck isn't usually writing code—it's understanding it. Between technical debt, architectural drift, and the 'bu... - [Semantic Search Over Your Codebase: LanceDB + pgvector in Practice](https://repowise.dev/blog/engineering/semantic-search-codebase-lancedb-pgvector): Every developer has experienced the 'grep fatigue.' You’re navigating a 100k+ LOC codebase, trying to find where a specific business logic—say, the grace per... ## Blog: Use Cases - [Case Study: We Build repowise With repowise](https://repowise.dev/blog/use-cases/repowise-on-repowise-case-study): repowise runs on its own codebase every day. Measured on paired benchmarks: 96% fewer context tokens (2,391 vs 64,039), 89% fewer file reads, quality at parity. - [Onboard Engineers Faster on Any Codebase](https://repowise.dev/blog/use-cases/onboard-engineers-faster): Onboard engineers faster on any codebase with an auto-generated wiki and 9 MCP tools that recover the why behind legacy code. See the 30-day approach inside. - [How to Read a Codebase You Didn't Write](https://repowise.dev/blog/use-cases/how-to-read-a-codebase-you-didnt-write): Read an unfamiliar codebase fast by treating the first pass like an incident review, not a refactor. Four lenses, an hour-by-hour workflow, and a repeatable audit memo. - [Incident Response: Finding the Change That Broke Production](https://repowise.dev/blog/use-cases/incident-response-find-recent-change): A production incident creates one question fast: who changed this code? The answer is rarely “the last commit.” It is usually a chain of changes, ownership… - [How the Repowise PR Bot Comments Only When It Matters](https://repowise.dev/blog/use-cases/repowise-pr-bot-silent-by-default): pr bot silent default is the only sane default for review automation. A GitHub PR bot should stay out of the way on green changes, then speak only when it… - [Audit a Flask monolith before acquisition with graph, history, wiki, ADRs](https://repowise.dev/blog/use-cases/audit-a-flask-monolith-before-acquisition-with-graph-history-wiki-adrs): Run a pre-acquisition code audit on a Flask monolith with graph, git history, wiki freshness, and ADRs. Find surprises before week two. - [Audit a legacy monolith before acquisition with graph, history, wiki, ADRs](https://repowise.dev/blog/use-cases/audit-a-legacy-monolith-before-acquisition-with-graph-history-wiki-adrs): Audit legacy code with graph, history, wiki, and ADRs to answer ownership, risk, and rewrite questions before a deal. See 4 layers in one review. - [Security review on a Python monolith with 19 hotspots](https://repowise.dev/blog/use-cases/security-review-on-a-python-monolith-with-19-hotspots): A security review codebase case study on a Python monolith: find 19 hotspots, map ownership gaps, and cut duplicate reads with one review path. - [47 dependents, 23 hotspots: a React refactor without folklore](https://repowise.dev/blog/use-cases/47-dependents-23-hotspots-a-react-refactor-without-folklore): A large codebase refactor case study: see how dependency graphs, git history, and ownership signals ranked 23 hotspots before the first React edit. - [The Engineering Manager's Guide to Codebase Visibility](https://repowise.dev/blog/use-cases/engineering-manager-codebase-visibility): Most engineering managers operate in a state of perpetual information asymmetry. While you have high-resolution data on sprint velocity, ticket throughput, a... - [How to Index a Monorepo: Docs, Graphs, and Ownership at Scale](https://repowise.dev/blog/use-cases/index-monorepo-docs-graphs-ownership): The monorepo is often the final evolution of a scaling engineering organization. By centralizing codebases, teams solve the 'dependency hell' of micro-repos,... - [Open Source Alternative to Enterprise Code Intelligence Tools](https://repowise.dev/blog/use-cases/open-source-code-intelligence-tools): Every developer has experienced the 'onboarding wall.' You join a new team, clone a massive mono-repo, and are immediately met with 500,000 lines of code, ze... - [What Happens When You Run repowise init on React (847 Files)](https://repowise.dev/blog/use-cases/repowise-init-react-847-files): Cloning a repository like React is a rite of passage for many engineers. It is the gold standard of modern UI library architecture, but it is also a formidab... ## Blog: Concepts - [Leiden communities vs PageRank for code hotspots](https://repowise.dev/blog/concepts/leiden-communities-vs-pagerank-for-code-hotspots): Use leiden community detection to separate hotspots from boundaries in a code graph. Compare it with PageRank and pick the right signal for one repo decision. - [RAG for code is not embeddings plus a vector store](https://repowise.dev/blog/concepts/rag-for-code-is-not-embeddings-plus-a-vector-store): RAG for code fails when it stops at chunks and vectors. See a 4-layer model with symbols, history, ownership, and a 36% cheaper retrieval path. ## Blog: Industry - [AI Code Review Tools Fail When They Ignore Ownership](https://repowise.dev/blog/industry/ai-code-review-tools-fail-when-they-ignore-ownership): AI code review tools catch lint, but miss ownership. See how local history and nearby changes cut bad reviews and surface the right reviewer. - [Codebase intelligence is becoming the missing layer for agents](https://repowise.dev/blog/industry/codebase-intelligence-is-becoming-the-missing-layer-for-agents): Why the codebase intelligence category is replacing raw file access: git history, ownership, and memory cut bad changes and speed agent work. - [Codebase RAG Breaks on Git History, Not Embeddings](https://repowise.dev/blog/industry/codebase-rag-breaks-on-git-history-not-embeddings): Why the codebase rag landscape fails after the first lookup: 4 indexing layers, 7 agent tools, and a cleaner path to ownership and change context. - [Developer productivity metrics that survive AI coding agents](https://repowise.dev/blog/industry/developer-productivity-metrics-that-survive-ai-coding-agents): Developer productivity metrics should track reruns, tool calls, context churn, and time-to-first-correct-edit. Use 4 signals to replace vanity counts. - [Codebase RAG buys you less than git history and ownership](https://repowise.dev/blog/industry/codebase-rag-buys-you-less-than-git-history-and-ownership): Why the codebase RAG landscape matters less than git history and ownership for a 50-person team. See the 4 questions that cut false leads. ## Blog: AI Coding - [Claude Code vs Cursor on a Python import cycle](https://repowise.dev/blog/ai-coding/claude-code-vs-cursor-on-a-python-import-cycle): Claude Code vs Cursor on one Python import cycle refactor: see the exact prompts, where each agent stalled, and which handled the graph better. - [Claude Code vs Cursor on a flaky Flask refactor](https://repowise.dev/blog/ai-coding/claude-code-vs-cursor-on-a-flaky-flask-refactor): Claude Code vs Cursor on one Flask refactor: same prompt, exact edits, and where each agent lost the thread. See the repo context that changed the outcome. ## Optional - [Full content dump](https://repowise.dev/llms-full.txt): Expanded page content for LLM ingestion - [Docs full content dump](https://docs.repowise.dev/llms-full.txt): Full documentation text - Support: hello@repowise.dev - GitHub: https://github.com/repowise-dev/repowise - Discord: https://discord.gg/cQVpuDB6rh - Docs: https://docs.repowise.dev (docs index for LLMs: https://docs.repowise.dev/llms.txt)