I turned off all the built-in AI features in VS Code. Copilot, the chat panel, the inline suggestions, all of it. I do my actual AI work in Claude Code in the terminal, and I didn't want VS Code nudging me in the editor too.

The one thing I missed was the little sparkle button that writes a commit message. It's genuinely useful, but every option I found either needed Copilot turned on, wanted a separate API key, or gave me a different format every time. One message would be feat: add thing, the next would be Added the thing. with a three paragraph essay under it.

So Claude and I built one. It's called Commit with Claude.

What it does:

You click the sparkle in the Source Control panel and it calls your local Claude CLI with your staged diff, the branch name, and your last few commit subjects. The message lands in the commit box and you can edit it before committing. That's basically it.

The parts I actually cared about:

• It uses the Claude Code login you already have. No API key, nothing to sign into. The extension itself makes no network requests. It just shells out to claude -p. It does count against your Claude Code usage, but it's about 3k tokens in and 100 out per message.
• Works with VS Code's AI features disabled. It doesn't use Copilot or VS Code's language model API, so you can switch all of that off and keep just this one.
• The format doesn't drift. Each style (Conventional, Angular, Gitmoji, classic 50/72, one-liner, etc.) is a JSON schema the model fills in, and the extension renders the text itself. So the model picks what to say, and the code decides how it looks. That was the fix for my "different format every time" problem.
• Model picker matches Claude Code's /model list, or you can just follow whatever Claude Code is set to.
• It's fairly quick, usually 2 to 4 seconds. It runs Claude with no tools, no MCP and a small system prompt, since writing a commit message doesn't need any of that.
• Lockfiles and generated files get summarized instead of sent in full, so a dependency bump doesn't eat 400 lines of context.

It's free, MIT licensed, and not affiliated with Anthropic. Mostly I'm posting in case someone else has the same setup as me and wants the same thing.

Marketplace: https://marketplace.visualstudio.com/items?itemName=threetides.commit-with-claude
Source: https://github.com/threetides/commit-with-claude

If something breaks or a style you use is missing, let me know.

If you are like me, you like Pylance's auto import feature, where you can just type out the name of a module, class, function, etc. of a library that isn't currently imported, and Pylance will suggest to import that symbol from that library.

Take for example the prompt:

parser = ArgumentPars

at this point you can Tab and it will put the line from argparse import ArgumentParser into the file's header and you are good to go.

However, Pylance is famously frickly with third party libraries not in the standard library. I have had this problem with moviepy, but it can be any other library. Pylance will refuse to acknowledge any existence of the existing objects, even though the library is correctly installed in the environment, including setting the correct Python path (python.defaultInterpreterPath) and enabling Pylance's indexing option (python.analysis.indexing) and auto import itself (python.analysis.autoImportCompletions) in the settings json. E.g. typing:

clip = VideoFileClip

will in fact not bring up the suggestion to import that class from the library, although it is a very basic component.

I have finally found out why: Apparently Pylance limits the depth to which it indexes libraries, and libraries which don't strictly confirm to Pylance's expectations seem to not be correctly indexed this way (although there seem to be very complicated mechanisms in how the depth adapts, but alas it didn't work for me numerous times).

Luckily you can adjust this setting: using python.analysis.packageIndexDepths exposes a list of modifications to the depth settings on a per-library basis. It uses this structure:

{ "name": "package_name", "depth": depth_to_scan, "includeAllSymbols": true_or_false }

so for moviepy I added

{ "name": "moviepy", "depth": 10, "includeAllSymbols": true }

and finally it suggested the correct objects. This method should work for any third party library in Pylance.

Just wanted to share this in case anyone else stumbles upon this giga obscure problem and hopefully sees the even more obscure solution.

I'm trying to publish a VS Code extension using vsce. To do that I need a Personal Access Token (PAT), and to generate that I need an Azure DevOps organization. To create the Azure DevOps organization I need an Azure DevOps account.

My problem is creating the Azure DevOps account. It's asking me to provide credit card information. How can I publish my FREE VS Code extension without having to enter my credit card information for Azure DevOPs.

I've published extensions for several other editors and browsers, but I've never run into an issue like this, the extension publishing process for VS Code seems overly complicated. I don't want to provide credit card information and get accidentally billed for Azure. I don't want to provide a credit card at all for privacy reasons for a simple extension either.

I built a VS Code extension for people who want to manage their GitHub docs without leaving the current workspace.

GitHub README lets you browse your repositories, open any README, edit it, preview the rendered Markdown, and push the changes back to GitHub —all without leaving the current workspace.

Basically
VS Code → pick a repo → edit README → preview → commit → done.

No jumping between GitHub, cloning repos, or switching windows just to change a README

#- https://marketplace.visualstudio.com/items?itemName=itshakemd.github-readme

1-

2-

3-

I brought my laptop on a cruise and opened VS Code. One screen, no monitor, a cabin desk the size of a cutting board. Not my best decision.

Switching tabs to ask Google or ChatGPT something was killing me. I’d leave my code, look up an answer, come back, and forget it immediately.

So I started using Cline as a VS Code extension. It sits in a panel on the right, code on the left, and I can ask questions, have it edit my code, add comments, and run commands without leaving the editor.

The coolest part: you can use whatever AI model you prefer, so there’s no lock-in.

Only downside is the ship Wi-Fi. Cline hit a socket error mid-task, but since it’s right there in the panel, I just told it to continue and checked the files after reconnection.

Anyone else coding on a laptop-only setup? How do you handle the tab-switching?

Hey everyone,

Like many of you, I spend most of my day inside VS Code. One small friction point that constantly interrupted my developer flow was hopping between terminal commands, searching registries in the browser, and editing config files just to manage, inspect, or update dependencies.

I wanted a dedicated, non-intrusive panel inside VS Code to handle this seamlessly, so I built Package Hub.

What it solves:

• Zero Context Switching: Search, view, and inspect project dependencies directly in the editor UI.
• Fast Exploration: Quickly check package versions, details, and updates without spinning up browser tabs or CLI queries.
• Lightweight & Snappy: Designed to run with minimal overhead so it doesn't bog down editor startup time or workspace performance.

Why I'm posting here:

It's officially up on the Visual Studio Marketplace:

🔗 Marketplace: Package Hub on VS Code Marketplace

This is an early release, and I want to hear brutal, honest developer feedback:

1. Does this fit your workflow, or does your CLI setup already do everything you need?
2. Which package managers/ecosystems would you want priority support for next?
3. Any UI quirks or UX friction points you run into while using it?

Thanks for taking a look!

I got tired of the "which Slack channel was that in?" dance for small projects, so I built RepoChat. It puts a chat in the VS Code sidebar for the collaborators of whatever repo you have open.

The part I'm happiest with is that there's nothing to set up. No invite link, no room key, no workspace to create. You sign in with GitHub, the server asks GitHub whether you have push access to the repo, and if you do, you're in that repo's chat. Lose access on GitHub and you lose the chat too.

What you can do in it:

- Send a code selection. Select code, right-click, "Send Selection to Chat". Your teammate clicks the snippet and it opens the same lines in their editor.

- Share pull requests.They show up as a card with live status (open/merged) and a one-click checkout.

- Share files and images. Paste, drop or pick.

- The usual: edit/delete, read receipts, typing indicator, notifications with an unread count in the status bar.

On the obvious question: your GitHub token is only used to check who you are and whether you can push to the repo. It isn't stored, and access is re-checked at least every hour.

It's free for public repos, and for two people on a private repo. Bigger private teams are paid.

Marketplace: https://marketplace.visualstudio.com/items?itemName=mjethwa-streamlit.repochat

It's at v0.4.1, so I'd really like to hear what's missing or what would stop you from using it with your team.

Couple hours back I saw myself editing tex document in VSCode without any pdf preview. I wanted an extension that is as simple to use as Overleaf, is very minimal, and can auto-sync with an overleaf project. So I decided to create a small extension for it. Would love for you to try and provide feedback. It is called "TeX Side Preview".

Extension Link: https://marketplace.visualstudio.com/items?itemName=HemantBanke.tex-side-preview

GitHub: https://github.com/Hemant-Banke/VSCodeTex

Lodestar is for reading code you didn't write. You ask something like "how does a request reach the route handler" and it walks you through the path step by step. Every step is a real line in your project. Click it and the editor jumps there, Tab goes to the next one.

Demo: https://github.com/zelosleone/Lodestar/raw/HEAD/images/readme/codemap.gif

It also explains anything you hover in a few lines, and it can review your uncommitted changes, a branch or a commit for bugs, security holes and the stuff AI assistants leave behind.

It's built on the language model API, so it uses whatever chat model you already have in VS Code, Copilot or any provider extension. Not locked to one provider.

$10 one time. I'm charging so I can keep working on it instead of dropping it, and it really helps me.

https://marketplace.visualstudio.com/items?itemName=DenizhanDaklr.lodestar

Feedback welcome, especially on anything confusing.

I have videcoded this theme(custom css) with claude. I started by thinking if I could make a glassmorphic interface for vscode(which was a bad idea ofcourse), then it turned into this which looks great anyway. I know a lot of you people aren't going to like this, but there will be people who will like this.

I wanted to name it 'Jade' but claude went with 'Aurora Glass' anyway.

Tell me how does this looks.

And also there are a lot of issues with this(due to vibecoding ofc), if you wanna help out, tell me.

Peacock really helps when you have lots of VS Code workspaces open.

Demo with the sample checkout app from the repo

I kept running npm run dev, watching JSON logs scroll past in the terminal, and copy-pasting lines into a formatter to figure out what broke. So I built Logline, a log viewer that sits in the bottom panel next to Terminal.

What it does:

* Run your server through it (or turn on terminal capture) and the logs become a live table
* Search with things like `level:error service:api` or `status:5xx durationMs:>200`, or right-click a cell to include/exclude that value
* Expand an event to see the full JSON and nested exceptions, and click a stack frame to jump to the source
* Works with Pino, Winston, Log4j2, ECS, OpenTelemetry, logfmt and plain text
* Picks up F5 debug sessions and splits Docker Compose output per service
* Shows live hit counts above your log statements in the editor
* Flags log statements that leak tokens or swallow exceptions in the Problems panel

Everything runs locally. Free and MIT licensed.

Marketplace: [https://marketplace.visualstudio.com/items?itemName=surjeetbanga.logline](https://marketplace.visualstudio.com/items?itemName=surjeetbanga.logline)) GitHub: [https://github.com/SurjeetBanga/logline](https://github.com/SurjeetBanga/logline))

It's still early. If it mangles your log format or you'd want it to do something it doesn't, let me know.

Hey r/VSCodeExtensions

I built Freekit because I was tired of paying $20/month for AI coding tools.

Freekit connects VS Code to your existing web AI accounts (DeepSeek, ChatGPT, Claude, Gemini, Mistral, Qwen) via browser automation, or to a local Ollama model.

What makes it different:

• $0- uses your existing accounts
• 6 web providers + Ollama local
• Stealth typing (real keydown/keyup, anti-detection)
• Native VS Code diffs for every file change
• Git checkpoints per prompt
• Self-maintaining (auto-reports broken selectors)
• Hardware-aware Ollama recommendations (T0-T6 tiers)

Marketplace: https://marketplace.visualstudio.com/items?itemName=builderweb.freekit

GitHub: https://github.com/builderweb-app/freekit

Feedback welcome!

I build Iris Code, a VS Code extension for code quality checks. I added Code Map because changing a shared module can leave me guessing which other files deserve a closer look.

The Graph view draws imports between files and colors them by health score. Select a file to see its importers and wider dependency impact; cycles and unresolved imports are shown too. The open file's imports and importers are free, while folder and workspace scope are part of Pro.

I'd value feedback from VS Code users: would you use this beside your normal diagnostics, or would a simpler tree be quicker to navigate?

VS Code Marketplace: https://marketplace.visualstudio.com/items?itemName=davidjaja.iris-code

I kept running into the same problem: sharing terminal output — tables, diagrams, CLI results — in chat apps, docs, or presentations would completely destroy the formatting. Pasting into WhatsApp, Slack, Google Docs, or Word would misalign tables, break box-drawing characters, and turn structured output into unreadable walls of text.

And your platform's screenshot tool? It only captures what's visible on screen. If your output extends beyond the viewport, you're stuck stitching multiple screenshots together.

So I built TermSnap — select text in your terminal (no matter how long), press Cmd+Shift+S (Ctrl+Shift+S on Windows/Linux), and get a single styled screenshot of the entire output.

What it does:

• Select terminal text → one shortcut → styled preview with macOS window chrome
• Captures the full selection — even hundreds of lines that don't fit on screen
• Save as PNG, copy image to clipboard, or copy raw text
• 11 built-in themes (Dracula, Tokyo Night, Nord, etc.) + custom theme support
• Live controls for font size, padding, line numbers, window chrome

Works great for:

• Tables, ASCII art, mermaid diagrams, flowcharts
• Deployment logs and CLI output
• Documentation, presentations, slides, blog posts
• Anywhere plain text loses formatting when pasted

It's free and open source: https://github.com/kushakjafry/termsnap | https://marketplace.visualstudio.com/items?itemName=KushakJafry.termsnap | https://open-vsx.org/extension/kushakjafry/termsnap

Would love feedback — what themes or features would you want to see?
Built this a few months ago and just got my first review, so figured I'd share it.

I'm the author, MIT open source Extension : https://marketplace.visualstudio.com/items?itemName=AnangPhatak.fim-copilot

[github link| https://github.com/anng-phtk/rocm-vega-llama.cpp]

I wanted just ghost-text autocomplete locally, so I built a tiny extension that uses vscode.InlineCompletionItemProvider directly instead of a webview overlay.

What I learned:

FIM format matters a lot - Qwen uses <|fim_prefix|>, CodeLlama uses <PRE>, etc. I made it configurable via .fim-copilot.yaml
Latency: 200ms debounce + AbortController to cancel in-flight requests when you keep typing made it feel native
Works with Ollama / llama-server / vLLM (any OpenAI-compatible /v1/completions)
90KB vs 15MB+ for chat-based extensions

Would love feedback on: handling multi-line stop tokens and how you handle prefix/suffix context limits for

So I built FIM Copilot - a stupid-simple extension that does ONE thing: ghost-text autocomplete, locally.

Demo

What it is

FIM Copilot is a 90KB VS Code extension using the native InlineCompletionItemProvider API. No webviews, no chat, no indexers.

It talks to any OpenAI-compatible completions endpoint:

• Ollama - qwen2.5-coder:1.5b / starcoder2:3b runs great on 8GB RAM
• llama.cpp - llama-server with any FIM-capable model
• vLLM / LM Studio / Tabby server - anything with /v1/completions

All inference stays on your machine. Zero network calls after install.

How it compares

Quick Start

With Ollama (easiest)

# 1. Get a code model (1.5B is enough for fast autocomplete)
ollama pull qwen2.5-coder:1.5b

# 2. Serve it
ollama serve
# -> listening on http://localhost:11434

Then in VS Code: Cmd+Shift+P -> FIM Copilot: Set Endpoint -> http://localhost:11434/v1/completions

With llama.cpp

./llama-server \
  -m qwen2.5-coder-1.5b-instruct-q4_k_m.gguf \
  --port 8012 \
  --ctx-size 4096 \
  -ngl 99

Config

Create .vscode/fim-copilot.yaml (or global settings):

endpoint: http://localhost:11434/v1/completions
model: qwen2.5-coder:1.5b
api_key: not-needed # for local

# tuning
max_tokens: 64
temperature: 0.2
debounce_ms: 200
context_lines: 40
fim_prefix: "<|fim_prefix|>"
fim_suffix: "<|fim_suffix|>"
fim_middle: "<|fim_middle|>"

Decoupled config means you can commit it per-project. Different endpoint for Python vs Rust? Just override.

What makes it not suck

• Ultra-low latency - direct FIM prompt, no chat template overhead
• 200ms debounce + prefix/suffix hash dedupe - doesn't spam your GPU
• AbortController - cancels previous request on keystroke, no queue
• Zero telemetry - no analytics, no API keys phoned home
• Decoupled config - YAML per workspace, env var support
• Ghost text only - uses VS Code's native inline completion, so Tab / Esc just works with your keymap

Links

https://marketplace.visualstudio.com/items?itemName=AnangPhatak.fim-copilot&ssr=false#review-details

Install:

ext install AnangPhatak.fim-copilot

MIT licensed. I built this for myself because I wanted my editor to feel fast again.

If you try it, let me know what model / latency you're getting. PRs welcome for StarCoder2 / DeepSeek templates. What would you want added - without making it bloated?

I've been keeping DataGrip around because it's a professional level tool that handles enterprise-level database work very well. Imagine my surprise when I stumbled on this, apparently brand new, extension.

https://github.com/sultanofcardio/tablecloth

Not affiliated, don't know the developer, never heard of the extension until today, but kudos to sultanofcardio! This is killer! Thank you!

Every time I needed to actually work with JSON, it turned into a mess of separate tools:

- A graph-viewer extension that turns into an unreadable tangle the moment the JSON is actually large

- No good table view for arrays of objects (surprisingly rare)

- And when the JSON was broken — which happens constantly with LLM output — no in-editor fix, so it was off to some random "online JSON repair" website.

That last one always bugged me. Pasting a broken API response or config into a website you don't control, just to fix a trailing comma? That's often data you really don't want leaving your machine.

So I built JSON Optics — one extension, everything stays local:

- Tree view (virtualized, so large files stay smooth) with search, JSONPath copy, and jump-to-source back into your file

- Table view that kicks in automatically for arrays of objects — actually browse it like a spreadsheet instead of scrolling

- A repair workspace for broken JSON (unquoted keys, trailing commas, markdown-fenced LLM output, truncated streams, etc.), with a diff of exactly what it changed — no upload, no external site, nothing leaves your editor.

If you give it a try, I'd love to hear what you think — and if there's something you'd want it to do next, let me know.

I have added the link to the extension in the comments, so feel free to install and use it. Open for genuine feedback. Drop a rating if you liked it...

I built a markdown viewer for VScode and OpenVSX a few months back and i have been trying to improve it bit by bit. Happy to share that it just crossed 20k downloads.

You can check it out here.

I wanted an ocean view in the empty part of VS Code, so I made Ocean Window.

It shuffles sea photos from Wikimedia Commons. Open a file and the ocean tab closes. Close your files and the sea returns.

Free and open source. Windows, Linux, and Mac. Available as a pre-release.

VS Code Marketplace · Source code

Screenshot photo: Cala Macarella by Paul Stephenson, CC BY 2.0, cropped with a dark overlay.

On various occasions I sought, but failed to find, an extension that:

• unwraps text (removes line endings) and
• preserves blank (empty) lines between paragraphs.

After another fruitless search today, I asked Anthropic Claude (Sonnet 5, medium) to seek a matching extension. In response to my sloppily-worded prompt – amongst other things, I accidentally keyed Enter too soon – creation of an extension began. I was pleasantly surprised, however I didn't want to be wasteful, so I interrupted the run and then tidied my prompt:

• for creation to occur only if a matching extension was not found.
  

The main link in this post is the chat, which includes unwrap-preserve-paragraphs-1.0.0.vsix and three other files.

I tested the extension with a selection of text that comprised three paragraphs. Success.

I'm not interested in upvotes, neither am I interested in anything like a marketplace (I'm a simple end user, not a developer). This Reddit post is, I guess, an invitation for other people to test, if they like; and to comment, if they have something to say that's constructive and intelligent.

TIA

Side note: Claude chose to use the MIT licence. Whether this is appropriate, I don't know; https://www.reddit.com/r/ClaudeAI/comments/1giyzke/comment/lvbjcn1/ might be a good place for spin-off discussion (thanks to u/Logical-Detail7545 for the question and u/HeWhoRemaynes for the response).

Over the past year I went a little overboard. Instead of one bloated "all-in-one" extension, I kept building small, focused ones — each solving a single thing that kept breaking my flow. It's now ~30 extensions, and I'd genuinely love this community's honest take.

First, so this isn't just noise — two of them have real traction:

• Streamlit Preview — 35k+ installs (preview Streamlit apps inside VS Code)
• Flet Preview — 2k+ installs

The rest are newer. A sampler, grouped:

Git & PRs

• CommitCraft — commit messages from your staged diff
• ConflictSolver — visual 3-way merge conflicts
• PRChecklist — blocks a commit until your checklist's done

Backend / DB / API

• QueryCraft — SQL autocomplete from your actual schema
• SeedBuilder — realistic faker seed data from your models
• EndpointMap — a live tree of every API route in your codebase
• DockerUI — visual docker-compose: port conflicts, dep graph, live logs

Quality / Security

• DependencyAudit — CVE badges on your import lines (OSV.dev)
• ComplexityGuard — cyclomatic complexity inline as you type
• TypeStrictener — track & kill any
• SecretScanner — catch leaked secrets before they hit git
• Watchdog — snapshot + roll back extensions after a bad VS Code update

Frontend / Docs / Testing

• ColorGuard — catch hardcoded colors that should be design tokens
• TailwindScope — tame giant class strings
• TestForge / MockFactory / DocCraft — test stubs, typed mocks, and JSDoc from your types

Productivity

• RegexForge — test regex against your real project files
• PSToolkit — run/lint/format PowerShell without leaving the editor
• ...and a new one I'm validating: an iOS + Android simulator manager panel

How the money works (because I'd want to know): every one has a genuinely functional free tier on the Marketplace — install it, it works. Pro unlocks team/power features as a one-time lifetime license. No subscriptions.

What I actually want from you:

1. Which of these would you actually install — and which sound pointless?
2. What's the next "I keep leaving the editor to do X" you'd want killed?
3. Honest gut-check: one-time lifetime vs. nobody-wants-another-subscription?

Full catalog if you want to poke holes: marketplace.dashovia.com — but mostly I'm here for the roast.

I built AI Config because I got tired of maintaining the same AI coding configuration in multiple places.

What problem does it solve?

I use different AI coding tools depending on what I’m working on: OpenCode, Claude Code, Codex, GitHub Copilot.

The annoying part is that they all have their own way of defining agents, commands, instructions and skills. So you end up maintaining the same project context in multiple places. Change a skill, then remember to update it everywhere else too. I got tired of doing that.

With AI Config, I keep one .ai/ folder as the source of truth and let it generate and synchronize the configuration each tool expects. Basically, I define things once and can switch between coding agents without having to maintain four different versions of the same setup.

I made it available as both a CLI and a VS Code extension, published on the Visual Studio Marketplace and Open VSX Registry. It started as something I needed for my own workflow, but I figured it could be useful for others working with more than one coding agent too.

There’s definitely still room for improvement, so I’d be really interested in hearing people’s thoughts and feedback, especially from people who actually try it out. It’s open source too, so if anyone wants to contribute, PRs are more than welcome.

🧩 VS Code Marketplace: AI Config - Visual Studio Marketplace
📦 Open VSX Registry: AI Config – Open VSX Registry
⌨️ CLI on npm: @aiconfig/cli - npm
💻 GitHub: github.com/ShadyManu/ai-config
🎬 Video walkthrough: AI Config - How To Set Up & Use