DebugAI: AI Debugger That Reads Your Whole Codebase

Every tool can see your errors now. Only DebugAI knows your codebase.

DebugAI finds the root cause of Python and JavaScript errors by reading your entire codebase, not just the line that crashed. It traces the error through your real imports and call chains, then returns a ranked fix with a diff you apply in one click. Root cause and 3 ranked fixes in about 8 seconds.

Works in VS Code, Cursor, Windsurf, and VSCodium. Also works as an MCP server for AI agents like Claude Code and Cursor agent mode.

VS Code Marketplace · Open VSX (Cursor, Windsurf, VSCodium) · debugai.io · Free tier, no credit card

What's new in 2.7.0

• Sign in from the editor. No key to find, copy, or paste. Run DebugAI: Sign In. The editor gets a short code, opens your browser, and stores the key itself once you confirm. The code lands on your clipboard so you paste it instead of retyping it, and the wait is cancellable. Free account, 10 debugs a day, no card. Pasting a dbg_ key still works if you prefer it, or if the machine has no browser.
• Every "no API key" dead end now signs you in instead. The first-run message, the error you get when analyzing without a key, and the setup nudge used to send you to a web page to fetch a key by hand. Now they sign you in where you already are.
• One-click connect works in Cursor, Windsurf, and VSCodium. The extension now passes its own URI scheme when it opens the dashboard, so the connect link comes back as cursor://, windsurf://, or vscodium:// instead of always assuming vscode://. That link silently did nothing outside VS Code before, which covers every install that came from Open VSX.

Previously in 2.6.0 - Verified badges + mechanical apply: every fix shows whether a mechanical check passed, failed, or never ran, and fixes carry exact old/new edits computed from your own code rather than regenerated text.

Previously in 2.5.0 - Proactive Scan: run DebugAI: Scan Workspace (Proactive) to catch bugs in your changed files before they throw. 20/20 planted bugs caught (12/12 cross-file) with 0 false positives in our 28-case benchmark.

Previously in 2.4.0 - Team Error Memory: "Seen before" and "Fixed before" badges when an error matches one your project already hit.

Full details in the changelog.

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 locally indexed codebase for the files that matter
3. Traces the failure across imports and call chains, not just the crash line
4. Returns the root cause plus 3 ranked fixes with confidence scores and exact file:line
5. Shows a diff preview before any change. You approve every edit

Median time from error to fix: about 8 seconds.

Get started in 60 seconds

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"
   One time, about 2 min. Free tier indexes up to 200 files.
4. Hit any error, Ctrl+Shift+P, "DebugAI: Analyze Terminal Error", done

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.

• Claude Code, Cursor agent mode, Windsurf, and other MCP clients can call the debug_error tool
• 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 team 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.

No extra install. Sign in once in the extension and the MCP server is live.

Not in VS Code? The same server ships standalone as @debugai/mcp on npm, 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, and it is why DebugAI catches cross-file bugs that paste based tools miss.

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 the files you changed on your current git branch (falls back to the active file if your working tree is clean), up to 10 files per scan
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 reproducible 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 corpus and runner ship in the repo under scripts/scan/benchmark/, so the number is reproducible rather than a marketing claim. 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

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. That is the only way to run it, deliberately.

DebugAI ships no default keybinding. Ctrl+Shift+D is VS Code's own Run and Debug view, and an extension that shadows it breaks a core editor feature. If you want a shortcut, bind one yourself in Preferences: Open Keyboard Shortcuts, search debugai, and pick a key that is free on your setup.

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: file content is sent over HTTPS, chunked, turned into embeddings by Voyage AI, and stored as a project index on DebugAI servers. Full source files are not stored as is, only semantic chunks for retrieval.
• During debugging: the error message, a small relevant code snippet of about 800 bytes, and recent git change metadata (file names only, never contents or diffs).
• When idle: nothing. No background scanning, no telemetry on your code.

API keys are stored in VS Code SecretStorage, never in plaintext settings files. 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: lock Pro at $9 per month for life if you upgrade before September 1, 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 locally 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? No. You run DebugAI: Index Entire Workspace yourself. Only files in your workspace are indexed, and only on your command.

What AI model powers DebugAI? Claude Haiku 4.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 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. DebugAI only runs when you invoke a command. 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.

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