DebugAI: AI Debugger That Reads Your Whole Codebase

The root cause of an error, from your actual code, and a fix you approve as a diff.

DebugAI finds the root cause of Python and JavaScript errors by reading your codebase, not just the line that crashed. It traces the error through your imports and call chains, then returns up to 3 ranked fixes, each as a diff you approve before anything changes.

• It knows your project. It indexes your workspace, so an answer can point at the function three files upstream that returned None, without you explaining your stack.
• You stay in your editor. Right-click the error, or press Ctrl+Alt+D (Cmd+Alt+D on a Mac). It can read the error straight from your terminal.
• Nothing changes until you say so. Every fix shows its file, line and diff first.
• Your agent can use it too. The same engine runs as an MCP server for Claude Code, Cursor and other agents.

Works in VS Code, Cursor, Windsurf and VSCodium. Free: 10 debugs a day, no card.

VS Code Marketplace · Open VSX (Cursor, Windsurf, VSCodium) · debugai.io

New in 2.12.0

Index Entire Workspace works again. From 2.10.0 it found no files in current VS Code, so answers only had the files you happened to open or save. If you used 2.10 or 2.11, run DebugAI: Index Entire Workspace once after updating.

Less leaves your machine. The extension no longer sends git context with a debug: not the git diff text, not your branch name, not the paths of your changed files. A focused .env, key or credential file has no code sent either. Automatic indexing has a setting (debugai.autoIndex) and a notice the first time it runs. Exactly what a debug sends is under Your code and your privacy.

A fix lands in the file it is for. When the fix belongs to a different file from the one the error named, Apply opens the diff against that file. Full list in the changelog.

If a fix does not work, tell me and I will fix it. The ones that did not work are how most of this release got written. Open your dashboard → Messages and say which error you sent and what the fix did instead. It reaches the person who builds this, and it gets answered.

What DebugAI does

You hit an error. Instead of pasting it into a chat window and explaining your whole project, you press one shortcut. DebugAI already indexed your code, so it traces the error across files and hands you the fix.

1. Reads the error from your terminal automatically
2. Searches your indexed codebase for the files that matter
3. Traces the failure across imports and call chains, not just the crash line
4. Checks what your project declares and which interpreter you have selected, so a package that is genuinely missing is told apart from one installed somewhere your editor is not looking
5. Returns the root cause plus 3 ranked fixes with confidence scores and exact file:line
6. Shows a diff preview before any change. You approve every edit

Median time from error to fix: about 7 seconds.

Get started

1. Install the extension
   VS Code: VS Code Marketplace
   Cursor, Windsurf, VSCodium: Open VSX, or search "DebugAI" in the
   extensions panel
2. Ctrl+Shift+P, "DebugAI: Sign In"
   Your browser opens, you confirm a short code, the editor stores the key.
   Nothing to copy or paste. Free account, 10 debugs a day, no card.
   (Already have a dbg_ key? "DebugAI: Set API Key" still takes it.)
3. Ctrl+Shift+P, "DebugAI: Index Entire Workspace"
   Once per project. Free tier indexes up to 200 files.
4. Hit an error. Ctrl+Shift+P, "DebugAI: Analyze Terminal Error",
   or Ctrl+Alt+D (Cmd+Alt+D on a Mac) in the editor

Step by step for your exact editor: debugai.io/start

Free tier: 10 debug sessions per day, no credit card.

Use DebugAI from AI agents (MCP server)

DebugAI ships an embedded Model Context Protocol (MCP) server. Any MCP aware agent can call DebugAI directly to debug errors across your codebase.

• VS Code agent mode can call the debug_error tool, and lookup_error first: an instant, free check of whether this project has seen the error and which fix held
• The agent sends an error or stack trace, DebugAI returns root cause plus ranked fixes with exact old/new string edits it can apply directly
• The server registers automatically in VS Code 1.101.0 and later, and reuses the key you already signed in with
• After applying a fix, the agent calls report_outcome to tell DebugAI whether it worked. Confirmed fixes join the same error memory that editor users build
• Responses are agent aware: when you hit your daily quota the tool tells the agent to stop retrying instead of looping

Your coding agent gets a debugging specialist rather than a generic guess. The agent reads the structured fix, applies the patch, reports back, and reruns your code.

In VS Code there is no extra install: sign in once in the extension and the MCP server is live for its agent mode.

Claude Code, Cursor, Windsurf, or not in VS Code? The same server ships standalone as @debugai/mcp on npm, for those and for Claude Desktop, Zed, Gemini CLI, Cline, and any other MCP client. One command signs you in and writes the config for every client it finds:

npx -y @debugai/mcp setup

Why codebase indexing beats paste and pray

Standard AI debugging: error, copy, paste into chat, explain your stack, get a generic answer, adapt it by hand, try again, repeat.

DebugAI: error, Ctrl+Shift+P, "DebugAI: Analyze Terminal Error", fix.

When the AI already read your project, it traces a NoneType error back to the function that returned None three files upstream, without you explaining anything. That is what real codebase context gives you: a pasted error alone cannot show the file the bug started in.

Proactive Scan, for bugs that have not thrown yet

Debugging is reactive: something crashes, then you fix it. Proactive Scan flips that around. It reviews your changed code for latent bugs before they ever throw.

Run DebugAI: Scan Workspace (Proactive) from the Command Palette. DebugAI:

1. Collects files with uncommitted changes (on a clean tree, files from your last 30 commits; with no git, the most recently modified), plus the active file, up to 10 files per scan (the welcome panel, right after a project's first index, offers up to 18); your plan decides how many are reviewed (3 on Free, 10 on Pro and Team), except that a project's first scan reviews every file it is offered
2. Auto-indexes them, then pulls the semantic neighbors from your project index, so it reviews each file with the rest of your codebase in context rather than in isolation
3. Returns ranked findings, each with a severity, an explanation, the exact file:line, and a suggested fix you preview and apply with the same one-click diff as debug

Because it reads cross-file context, Scan catches defects a single-file linter cannot see: a function called with the wrong arguments defined in another module, a return-shape mismatch between two files, a config value that causes a divide-by-zero two files away, an interface a caller quietly violates.

It is tuned to stay quiet on correct code. A scan that cries wolf is worse than one that says nothing. In our benchmark of 28 original test cases (written from scratch, not pulled from public repos), Proactive Scan detected 20 / 20 planted bugs, including 12 / 12 cross-file bugs, with 0 false positives on 8 clean-code controls. The latest run was on 2026-08-08, against our staging service, before the move to Claude Haiku 5.5. The corpus and runner live in our own repository, which is not public, so this is a measurement we made and not one you can rerun. No competing tool was run against this corpus, and we say so rather than let the number imply a comparison that does not exist.

Scan limits by tier

A project's first scan reviews every file it is offered whatever your plan (up to 10 from the command, up to 18 from the welcome panel that opens after the first index), and stops once it has three findings worth showing.

Errors DebugAI handles

• Python AttributeError, including 'NoneType' object has no attribute
• Python TypeError, wrong argument types, None passed where an object was expected
• Python NameError, ImportError, ModuleNotFoundError, KeyError, IndexError
• JavaScript and TypeScript TypeError: Cannot read properties of undefined
• React hooks errors, stale closures, infinite render loops, missing dependencies
• Runtime exceptions and tracebacks that span multiple files

How to run DebugAI

Open the Command Palette (Ctrl+Shift+P or Cmd+Shift+P) and type DebugAI to see every command. Two shortcuts skip the palette:

• Right-click in a file for Analyze Error, or in the terminal for Analyze Terminal Error.
• Ctrl+Alt+D (Cmd+Alt+D on a Mac) analyzes from the editor.

DebugAI does not take Ctrl+Shift+D. That is VS Code's own Run and Debug view, and an extension that shadows it breaks a core editor feature. To change the shortcut, open Preferences: Open Keyboard Shortcuts and search debugai.

Commands

Supported languages and frameworks

Python: FastAPI, Django, Flask, Celery, SQLAlchemy, Streamlit, PyTorch, TensorFlow, Pandas, NumPy

JavaScript and TypeScript: React, Next.js, Node.js, Express, Vue, Svelte, Vite, tRPC

Framework detection is automatic. No config files needed.

Your code and your privacy

• During indexing: while you are signed in, DebugAI indexes the project you have open: once when VS Code starts, and again for each file you open or save. Each file's text (up to 50 KB) is sent over HTTPS, up to 500 files per run on any plan (Free keeps 200). It is split into chunks, turned into embeddings by Voyage AI, and stored on DebugAI's servers as chunks of text, each with its embedding. .env files, key and certificate files, and build or dependency folders are never sent. The first time it runs, a notice tells you this. Set debugai.autoIndex to false and only the Index commands and Scan send files.
• During debugging: the error message, the code around your cursor (30 lines either side, never more than 50,000 characters), unless that file is an environment file, a key or certificate file, or a credential file (such as .npmrc, .netrc, .git-credentials, or anything under .ssh or .aws), or the window holds a private key, in which case no code is sent and the status bar says so, the full path of the file you are in, and a few facts about the project: the dependency names and versions your manifest files declare, the names of Python modules in your workspace, whether a virtual environment or node_modules folder exists, and the path of the Python interpreter VS Code has selected. No git information goes with a debug: from 2.12.0 it carries no branch name, no changed file paths and no git diff text (2.11.0 and earlier sent the branch name, changed paths and up to 3,000 characters of git diff text). The bundled MCP server, when your agent calls it, also reads up to 3 of the source files a stack trace names, 40 lines either side of the error.
• Debug in Browser (closed beta): for a failed network request it sends the method, URL, status, request and response headers, and both bodies. Credential headers (Authorization, Cookie, Set-Cookie and any name that looks like a key, token or secret) are dropped first, and bodies pass through secret redaction before they are cut to length.
• Proactive Scan: the command picks up to 10 files (the welcome panel after a project's first index offers up to 18) whatever your plan, indexes their text as described under indexing whether or not debugai.autoIndex is on, and sends their paths, sizes and a recency score (uncommitted changes rank highest) to be scanned; your plan decides how many are reviewed (3 on Free, 10 on Pro and Team), except that a project's first scan reviews every file it is offered. It uses git only to choose files, and sends no history, branch name or diff. DebugAI keeps each finding's file path, line and severity, to show you the result and to learn whether a fix was used.
• Everything else: no code and no file names. The extension asks DebugAI for your plan, usage and product notices, and reports counts of its own errors. It also reports whether a fix helped or was applied and which notices you saw. While VS Code telemetry is on, it sends usage events (event names, language, plan, counts; no code or paths) to PostHog under your account id. No telemetry on your code.

Browser sign-in keeps your API key in VS Code SecretStorage. A key starting with dbg_ typed into the debugai.apiKey setting is moved there the first time DebugAI uses it, and sits in settings.json until then. Signing in through the browser never puts the key on your clipboard or in a settings file at any point.

Privacy policy

Pricing

Monthly prices shown. Full feature breakdown and annual options live at debugai.io/pricing.

Founding rate, closing soon: accounts created before November 1, 2026 can lock Pro at $9 per month for life by upgrading by December 7, 2026. Claim it.

Frequently Asked Questions

What is DebugAI? DebugAI is a VS Code extension and MCP server that finds the root cause of code errors by reading your whole codebase, then returns ranked fixes with a diff you apply in one click.

How do I set it up? Install it, then run DebugAI: Sign In from the Command Palette. Your browser opens, you confirm a short code, and the editor stores the key. There is no key to locate, copy, or paste.

How does DebugAI debug errors across multiple files? It indexes your project on DebugAI's servers first. When an error happens, it searches that index, traces the failure through your imports and call chains, and reads the files that actually caused the error, not just the crash line.

Does DebugAI read my entire codebase without asking? Yes, by default. While you are signed in it indexes the open project at startup and each file you open or save. Set debugai.autoIndex to false and only the Index commands and Scan send files.

What AI model powers DebugAI? Claude Haiku 5.5 handles analysis. Complex cross-file errors on paid tiers route to Claude Sonnet 4.6. If Claude is ever unavailable, DebugAI falls back automatically to GPT-4o-mini. The response format is identical either way.

Can I use DebugAI with Claude Code or other AI agents? Yes. DebugAI includes an MCP server that exposes lookup_error, debug_error and report_outcome. Any MCP aware agent can call it. Sign in once in the extension and it works automatically in VS Code 1.101.0 and later. Outside VS Code, npx -y @debugai/mcp setup wires up every MCP client on the machine.

Does it conflict with GitHub Copilot? No. It does not interfere with Copilot, Copilot Chat, or any other extension. It is the debugging companion to your existing AI stack.

Does it work in Cursor, Windsurf, or VSCodium? Yes. DebugAI is a standard VS Code extension, so it runs in any VS Code compatible editor. Install it from Open VSX, and browser sign-in works the same way it does in VS Code.

Does it work offline? No. Indexing and analysis both need a connection to the DebugAI API.

How many free debug sessions do I get? 10 per day, free forever. Need more, upgrade to Pro from debugai.io/pricing.

Recent releases

2.12.0 - a debug no longer sends git context, automatic indexing has a setting and a notice, and Index Entire Workspace finds your files again after storing nothing since 2.10.0. A fix for another file opens against that file, a Pro or Team account hears once a month when its included debugs are used, and the listing now says what is sent and where.

2.11.0 - the MCP server VS Code registers for your agent answers from your project's memory first. lookup_error says in under a second, free and with no model call, whether this project has hit the error before and which fix held. debug_error takes the command that reproduces the failure and aims fix #1 at making it pass. A fix that worked only after the agent changed it is remembered as changed, a fix reported as failed is not handed back at full confidence, and every answer names the project it was filed under and the build that wrote it. Built from one agent's week-long field report, finding by finding.

2.10.1 - the bundled MCP server accepts all 24 languages it can diagnose, your operating system's own error messages are sent instead of refused, and a project path with a space in it no longer truncates.

2.10.0 - The bundled MCP server now sends what your project declares, with versions, so answers about third-party APIs are grounded in the release you actually have. Repeated errors at the same file and line no longer get a variation of the fix that just failed. Indexing now covers Java, C# and your build config, chooses your source files over snapshots and fixtures when a project is larger than your plan indexes, and tells you what it could not store. The bundled MCP server never opens your .env.

Full changelog

debugai.io · support@debugai.io · Privacy · Terms