5 VS Code Extensions That Make AI Coding Tools 10x Better

# 5 VS Code Extensions That Make AI Coding Tools 10x Better

Everyone’s talking about [GitHub Copilot]# and [Cursor]#. Fair enough — they’re genuinely transformative. But after months of pairing them with a carefully tuned VS Code setup, I’ve noticed something: the AI doesn’t work in a vacuum. It works with *whatever context you give it* and *whatever friction exists in your editor*. Strip out the friction, feed the AI better context, and you get results that feel like a different product entirely.

Here are the five extensions I consider non-negotiable in 2026 for any serious AI-assisted workflow. I’ll give you the extension ID, a concrete setup, and exactly how each one makes your AI tool smarter or faster.

Why Your AI Tool Is Only as Good as the Environment Around It

AI coding assistants — Copilot, Cursor, Tabnine, Codeium — all rely on two things: the code visible in your editor and the signals you give them. They’re reactive, not omniscient. If your editor is cluttered with unread errors, orphaned TODOs, and no git history visible, the AI is flying blind.

The extensions below address exactly that. They’re not novelties. Each one either:

• Adds context the AI can use to generate better suggestions, or
• Removes friction so you can act on AI output faster.

Let’s get into it.

Extension 1: GitLens — Richer Code History Context for AI Tools

Extension ID: eamodio.gitlens Install: ext install eamodio.gitlens

GitLens is the most downloaded git extension in the VS Code marketplace, and for good reason. But most people use it for blame annotations. That’s the tip of the iceberg.

The real value for AI-assisted development is inline history and rich diff views. When you’re asking Copilot or Cursor to refactor a function, it helps enormously to have *why that function was written that way* visible. GitLens surfaces this without you leaving the file.

Specifically useful:

• Line blame shows the last commit message inline — feed that context directly into your AI chat prompt
• File History (GitLens: Show File History) lets you see how a file evolved; paste a diff into Cursor’s composer for smarter refactors
• Heatmap overlays make it obvious which code is recent vs. legacy — useful context when prompting for rewrites

Recommended settings (settings.json):

"gitlens.hovers.enabled": true,
"gitlens.currentLine.enabled": true,
"gitlens.blame.highlight.enabled": true,
"gitlens.codeLens.enabled": true

GitLens Pro (# — see footer disclosure) unlocks deeper workspace-wide history views and visual file history timelines, which is worth it if you’re working on legacy codebases where AI refactoring is highest-impact.

Extension 2: Error Lens — Inline Errors So Copilot Can Fix Faster

Extension ID: usernamehw.errorlens Install: ext install usernamehw.errorlens

The default VS Code error experience is: red squiggle → hover → read tooltip. That’s three interactions before you even know what’s wrong. Error Lens collapses that to zero — errors appear inline, right at the end of the line they affect.

Why does this matter for AI tools? Because Copilot’s inline fix suggestions are triggered by visible diagnostic messages. With standard squiggles, you’re often not looking at the right line when Copilot decides what to suggest. Error Lens makes every error permanently visible, which means:

• Copilot’s context window sees the error message alongside the code
• You can select an entire error-annotated block and say “fix this” with full confidence you’ve included the right lines
• In Cursor’s composer, you can screenshot or paste the inline error text directly as part of your prompt

Recommended settings:

"errorLens.enabledDiagnosticLevels": ["error", "warning", "info"],
"errorLens.fontSize": "13",
"errorLens.fontStyle": "italic",
"errorLens.delay": 200,
"errorLens.gutterIconsEnabled": true

Set the delay to 200ms rather than the default 0 — it prevents the display from flickering during active typing.

Extension 3: REST Client — AI-Assisted API Testing Without Leaving VS Code

Extension ID: humao.rest-client Install: ext install humao.rest-client

Postman is a great tool, but it’s a context switch. Every time you leave VS Code, you break your flow — and more importantly, you lose the AI’s visibility into what you’re testing.

REST Client lets you write .http files directly in your project. Those files are just text, which means Copilot can read them, complete them, and help you write them.

Here’s a real example: I was building a webhook handler and had Copilot autocomplete my .http test file based on the handler signature it could see in the adjacent file. It got the headers and body schema right on the first suggestion.

A sample .http file with AI-friendly structure:

### Create user
POST https://api.example.com/users
Content-Type: application/json
Authorization: Bearer {{authToken}}

{
  "name": "Alex Chen",
  "email": "alex@example.com",
  "role": "admin"
}

### Get user by ID
GET https://api.example.com/users/{{userId}}
Authorization: Bearer {{authToken}}

Variables like {{authToken}} are resolved from a .env file in your project root — so secrets stay out of your .http files. Copilot sees the structure and can generate additional request blocks when you describe what you need in a comment.

Recommended settings:

"rest-client.environmentVariables": {
  "local": {
    "baseUrl": "http://localhost:3000",
    "authToken": ""
  },
  "production": {
    "baseUrl": "https://api.example.com",
    "authToken": ""
  }
},
"rest-client.previewOption": "body"

Extension 4: Todo Tree — Keeps AI-Generated TODOs Actionable

Extension ID: gruntfugly.todo-tree Install: ext install gruntfugly.todo-tree

AI tools generate a lot of // TODO: comments. Copilot does it when it can’t complete something confidently. Cursor does it when scaffolding components. Without a way to track them, they quietly accumulate into technical debt.

Todo Tree scans your entire workspace and surfaces every TODO, FIXME, HACK, and NOTE in a dedicated sidebar panel. Click one, jump straight to it.

More importantly: you can pipe that list directly back to your AI. I regularly open Todo Tree, copy the full list of outstanding TODOs from a file, paste it into Cursor’s chat, and say “tackle these in order.” The AI has the full file context plus the explicit task list. It’s a clean workflow.

Recommended settings:

"todo-tree.general.tags": ["TODO", "FIXME", "HACK", "NOTE", "REVIEW", "AI-TODO"],
"todo-tree.highlights.defaultHighlight": {
  "icon": "alert",
  "type": "text",
  "foreground": "#fff",
  "background": "#ff9900",
  "opacity": 50,
  "iconColour": "#ff9900"
},
"todo-tree.highlights.customHighlight": {
  "AI-TODO": {
    "icon": "hubot",
    "iconColour": "#7c6af7",
    "background": "#7c6af730"
  }
}

Note the custom AI-TODO tag — I use this specifically for items I’ve flagged for AI follow-up. Makes it easy to filter the panel to just AI-pending work.

Extension 5: Markdown All in One — AI-Assisted Docs and READMEs

Extension ID: yzhang.markdown-all-in-one Install: ext install yzhang.markdown-all-in-one

Documentation is the most underrated use case for AI coding tools. Copilot is excellent at generating README sections, API docs, and changelogs — but only if your Markdown editing experience doesn’t get in the way.

Markdown All in One adds:

• Auto-generated table of contents (updated on save)
• List continuation (hit Enter in a list, it continues it)
• Ctrl+B / Ctrl+I bold/italic shortcuts that work like a normal editor
• Live preview pane synced to your cursor position
• Math rendering for documentation that includes formulas

For AI-assisted docs specifically, the ToC auto-generation is the killer feature. Write your headings with Copilot’s help, run Markdown All in One: Create Table of Contents, and your docs are instantly navigable. The preview pane also helps you verify that AI-generated Markdown renders correctly before you commit it.

Recommended settings:

"markdown.extension.toc.updateOnSave": true,
"markdown.extension.toc.levels": "2..4",
"markdown.extension.preview.autoShowPreviewToSide": false,
"markdown.extension.italic.indicator": "_"

I turn off autoShowPreviewToSide because Copilot suggestions are harder to review with the split pane active. Open preview manually with Ctrl+Shift+V when you need it.

Bonus: Keybinding Config for Seamless AI Integration

This is the part most people skip. Your AI tools have keyboard shortcuts — but the defaults often conflict with each other or with VS Code’s native bindings. Here’s the keybindings.json configuration I’ve landed on after iterating for months.

Open it with Ctrl+Shift+P → “Open Keyboard Shortcuts (JSON)”.

[
  {
    "key": "ctrl+shift+a",
    "command": "github.copilot.generate",
    "when": "editorFocus"
  },
  {
    "key": "ctrl+enter",
    "command": "github.copilot.openCompletionPanel",
    "when": "editorFocus"
  },
  {
    "key": "alt+]",
    "command": "editor.action.inlineSuggest.showNext",
    "when": "inlineSuggestionVisible && !editorReadonly"
  },
  {
    "key": "alt+[",
    "command": "editor.action.inlineSuggest.showPrevious",
    "when": "inlineSuggestionVisible && !editorReadonly"
  },
  {
    "key": "ctrl+shift+t",
    "command": "todo-tree.showTree",
    "when": "workspaceFolderCount > 0"
  },
  {
    "key": "ctrl+shift+g l",
    "command": "gitlens.showFileHistoryView",
    "when": "editorFocus"
  },
  {
    "key": "ctrl+alt+r",
    "command": "rest-client.request",
    "when": "editorLangId == 'http'"
  }
]

A few notes on this config:

• ctrl+shift+a fires Copilot’s inline generation — avoids conflicts with standard ctrl+. fix suggestions
• alt+[ and alt+] cycle through multiple Copilot suggestions without reaching for the mouse
• ctrl+shift+t toggles the Todo Tree panel — fast access to your AI-generated task backlog
• ctrl+alt+r executes the current REST Client request when you’re in a .http file

The Complete Setup: Putting It Together

Here’s the full extension list, ready to drop into a .vscode/extensions.json file for team sharing:

{
  "recommendations": [
    "eamodio.gitlens",
    "usernamehw.errorlens",
    "humao.rest-client",
    "gruntfugly.todo-tree",
    "yzhang.markdown-all-in-one"
  ]
}

Commit this file to your repo. Anyone who opens the project in VS Code gets prompted to install the full stack.

The through-line across all five extensions is the same: reduce friction, add context. GitLens surfaces history. Error Lens surfaces diagnostics. REST Client keeps API tests in-editor. Todo Tree tracks AI-generated debt. Markdown All in One keeps documentation clean. Together, they create an environment where your AI tool — Copilot, Cursor, Tabnine, whatever you’re using — has more to work with and you have fewer reasons to leave the flow state.

The AI tools are impressive. But the extensions around them are what make the setup yours.

Got an extension that makes your AI setup better? Drop it in the comments.

*If you’re not using [GitHub Copilot]# or [Cursor]# yet, those are the two I’d start with. Both offer free tiers.*

> FTC Disclosure: This post contains affiliate links. If you purchase a product through one of these links, EasyOutcomes.ai may earn a small commission at no extra cost to you. We only recommend tools we actively use and stand behind.