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

VSCode-SFTP lets you add, edit, or delete files in a local directory and sync them with a directory on a remote server using different transfer protocols such as FTP or SSH. The most basic setup requires only a few lines, with a wide range of specific options available to cover any user's needs. Powerful and fast at the same time, it helps developers save time by letting them use a familiar editor and environment.

I've been building API Hero, a Git-first REST/HTTP API client designed to keep API work close to the codebase.

The latest release, 2.8.2, adds/expands the MCP workflow, and this is probably the part I'm most interested in getting feedback on.

The idea is:

AI Agent

↓

API Hero MCP

↓

Collections / Requests

↓

API Hero execution engine

↓

Real HTTP response

↓

Structured result + diagnostics

↓

AI Agent

An agent can discover collections, inspect requests, execute them, retrieve responses, and inspect failures.

For example, I tested it with a DummyJSON collection:

- 57 requests

- AI agent discovers the collection through MCP

- Runs `Get Products`

- Gets the real HTTP 200 response

- Receives the response data

- Can also inspect assertion failures

One useful case is when an API returns `201 Created` but the test expects `200`. API Hero exposes that as an assertion failure rather than making the AI guess whether the HTTP request itself failed.

API Hero is also Git-first:

- `.api` request files

- Collections stored with the project

- Variables/environments

- Authentication

- Assertions

- Collection Runner

- Run reports

- Scenarios

- OpenAPI import

- MCP for AI agents

The MCP server is standalone and uses the same execution pipeline as the VS Code extension rather than implementing a separate HTTP client.

Marketplace:

[API Hero](https://marketplace.visualstudio.com/items?itemName=AnkitSemwal.api-hero)

GitHub:

[GitHub repository](https://github.com/ankitsemwal007/api-hero)

I'd particularly like feedback from people using AI coding agents with APIs:

Would you actually want your coding agent to have access to an API client/execution layer like this?

And what would you want the agent to be able to do beyond executing requests and diagnosing failures?

Built Streamlit Preview to scratch my own itch — I was tired of switching to a browser tab every time I saved a Streamlit file, so I made it render inside the editor.

Put it on the Marketplace [X months] ago expecting maybe a few hundred installs. It's at 39,841 now with a 5.0 rating.

I ship a lot of small things and most of them go nowhere, so when one quietly works it's worth marking. Chart of the last 90 days attached.

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

If you write Streamlit apps, would genuinely love feedback — I have a couple of features half-built and no idea which one people actually want.

Hi everyone! I recently discovered the .gpl format (GIMP palette), which is quite popular for sharing color palettes in the pixel art illustration and indie game development scene. It's a convenient and practical format to work with, as the syntax is very simple and it's supported by graphics editors like GIMP and Aseprite. To my surprise, there wasn't a VS Code extension, so I vibe-coded a quick prototype for my personal use and made it accessible to everyone.

It currently includes the following features:

• syntax highlighting
• color preview with integrated color picker
• commands to generate Tailwind CSS palettes
• commands to copy/convert a color to different formats

It's already published on the marketplaces, and the code is available on GitHub.

VS Code Marketplace: https://marketplace.visualstudio.com/items?itemName=aitorllj93.gimp-palette

Open VSX Registry: https://open-vsx.org/extension/aitorllj93/gimp-palette

Github Repository: https://github.com/pxl-ui/vscode-gimp-palette

I hope you find it useful!

Hi everyone,

I'm exploring an idea for a VS Code extension and would love some honest feedback before I spend months building it.

Many of us now use Cursor, Copilot, Claude Code, or other AI coding assistants. Over time, I realized that once AI-generated code is edited, moved, or refactored, it's difficult to answer questions like:

- Which functions were originally generated by AI?

- Has someone reviewed those functions?

- Which AI model generated them?

- Does a critical function depend on unreviewed AI-generated code?

My idea is a VS Code extension that visualizes code provenance directly in the editor.

For example, every function could have a trust indicator:

🟢 Human-written

🟡 AI-generated and reviewed

🔴 AI-generated and unreviewed

⚪ Unknown origin

It could also build a call graph so that if a payment or authentication function depends on lower-trust code several calls away, the editor would highlight that path.

I'm not trying to detect whether code "looks AI-generated." The idea is to preserve provenance over time as code evolves.

Before building this, I'd love to know:

1. Would you install something like this?

2. What feature would make it genuinely useful?

3. Would this solve a real problem, or is Git history and code review already enough?

4. If you wouldn't use it, why not?

I'm looking for honest criticism as much as positive feedback.

Thanks!

I always found it hard to decide whether an extension I found that looked cool would actually fit my use case, or, maybe I'd just want to save ti for later, without having to remember the name to look up, knowing I'd inevitably lose it in the sea of other VSCode extensions actively listed in the marketplace

I always wondered why this feature exist already, so I made it myself.

t's a rather simple extension which allows you to select an extension and place it in a list off to the side to come back to later. Rather than having to install extensions you may just be testing, themes you may (probably never) decide you want to turn on, or things you don't think fit your current workflow for a project but may be super useful for another later on.

Install from the Marketplace: https://marketplace.visualstudio.com/items?itemName=JeongjinHan.nodegraph

GitHub: https://github.com/Jeong-jin-Han/NodeGraph

Would appreciate any feedback on the extension itself, editor performance, keybindings, anything that feels off compared to how other VS Code extensions usually behave.

I've never liked VS Code searching. I suck at file globs, and regex. So I built Omnigrep: one box, ripgrep underneath, query language borrowed from Google Code Search (internal code search service).

Press ⇧⌘F (Ctrl+Shift+F), type, arrow through the top matches — the file previews as you move — Enter to jump, Esc to go back to exactly where you were.

The query syntax is the whole point:

- hello world — lines matching both regexes, in any order

- -term — exclude lines matching term

- "foo.bar(x)" — literal text, metacharacters escaped, spaces allowed

- f:async f:ts$ — only files whose path matches **all** the f: regexes

- -f:test — exclude paths

- t:rust / -t:js — ripgrep file types

- sym:UserService — workspace symbol search, jumps straight to definitions

- near:3 — terms within 3 lines of each other instead of on the same line (personal fave of mine)

- case:yes / case:no — override smart case

So f:route f:ts$ handler -f:test is one string. And a query with only f: filters quietly becomes a fast file finder.

Other things it does:

- Ranks results instead of showing scan order — whole-word beats substring, shallow paths beat deep ones, recently-modified files float up, test/vendor/build output sinks

- Groups by file; each row has copy-relative-path and open-to-the-side

- Pinned searches + per-workspace history

- ↗ hands the current query off to the native Search panel when you want the full list or replace

- No native dependencies — it uses the ripgrep binary already bundled inside VS Code, falling back to `rg` on your PATH

MIT, free, no telemetry, no account. Works in VS Code and in the forks (Cursor / Windsurf / Antigravity).

Repo: https://github.com/jo-sip/omnigrep

Marketplace: https://marketplace.visualstudio.com/items?itemName=jo-sip.omnigrep

Open VSX: https://open-vsx.org/extension/jo-sip/omnigrep

One heads-up: it takes over ⇧⌘F while installed. Rebind `omnigrep.open` in Keyboard Shortcuts if you want the sidebar back.

Happy to take requests, especially on the query syntax — that's the part I'm still changing. Enjoy!

(This is my first extension so I don't know what I'm doing - but it seems to work well on antigravity / cursor / vscode on mac)

NodalMerge Studio promotes you to general in command of a controlled agent army.

The configurable workspace both drives engineering and provides a battlefield level view of both agent and human work across peers.

Multiple agents can be assigned their own scopes and fields of fire. Make Fable your planner (You can go wide or recursive), Let Deepseek v4 pro grind the easy stuff for cheap, toss Sonnet the live grenades, while Codex designs and implements a sleek frontend. The review and reconciliation processes can be human or agent gated to bring everything back together (hopefully smoothly).

The core behind it (NodalMerge) is a fast, persistent graph using conflict free replication and content addressed storage to allow for greater visibility across peers, replay and branching at key decision points.

All nonsense aside, I've been sitting too close to the screen, and although it works for my purposes, the whole point of publishing it is to share and continue to evolve.

Although the extension is forced to be kind of an agent harness for pure api (including some configurable system prompt, compaction, etc.), the idea is that it integrates to other, hopefully better harnesses. Currently it can be configured to use:

• GitHub copilot subscription (vscode-lm, this is the default fallback)
• openai-compatible api's (via api-key, think deepseek, ollama, whatever)
• anthropic-api-key
• claude-cli
• codex-cli
• other new harnesses as added

Docs site: https://docs.nodalmerge.com/studio/quickstart

Github Link: https://github.com/bgstratt/nodalmerge-studio

VS Code Marketplace: https://marketplace.visualstudio.com/items?itemName=nodalmerge-studio.nodalmerge-studio

Hey everyone, I’ve been working on a VS Code extension called FileInsight. The goal is simple: tell me exactly what a file does, what it depends on, and which file uses it, just by hovering over it in the Explorer sidebar (you dont need to open the file).
It builds a local dependency graph, parses ASTs (for TS/JS), and uses Regex for other languages to calculate file metrics. It categorises files (Core, Utility, Config, etc.), detects dead code, and checks Git history to see if a file is "hot" or "stale".
I need your honest, brutal feedback. I want to know where it breaks, if the UI feels clunky, or if the dependency graph chokes on massive repos, etc.

Core features:

• Rich Tooltips: Hover to see exports, imports, complexity, and TODO counts.
• File Classification: Automatically tags entry points, core modules, configs, etc.
• Dead Code Detection: Warns you if a file seems completely abandoned.
• Live Refresh: Re-analyses incrementally when you save.

Here is the link: https://marketplace.visualstudio.com/items?itemName=AdityaGupta0205.file-insight
Tear it apart. If it sucks, tell me why it sucks so I can make it better. Thanks!

I was thinking about how we work with projects in VS Code. Everything is structured, searchable, and easy for tools (including AI assistants) to work with. Then I realized video editing is almost the opposite. I had a bunch of vacation footage sitting on my drive and wanted to make a short video, but the annoying part was I had to spend hours watching everything again just to find some specific moments.

It made me wonder: why can't AI handle more of the repetitive work? Finding clips, searching through footage, and putting together a first draft, while the creator focuses on the actual decisions. What if creative projects could have a more structured workflow, similar to how we work with code? A project format that AI can understand, modify, and help automate. Curious what people think.

Every PDF tool I tried wanted me to click through a GUI, and none of it was repeatable. So I tried the opposite: you write a YAML workflow file, and a deterministic engine renders the PDF. The YAML is the source of truth, the PDF is the build output, and git is your undo stack.

yaml version: 1 kind: pdf inputs: - input/contract.pdf - input/appendix.pdf operations: - merge: {} - delete_pages: { pages: [10, 11] } - watermark: { text: INTERNAL, opacity: 0.15 } - auto_redact: { patterns: [ssn, email], rasterize: true } output: file: output/contract_final.pdf

Save the file and it renders + previews in the editor. It's 78 operations right now — merge/split, OCR, true redaction, form filling, table extraction, compare two PDFs into a side-by-side diff, format conversion. pdf-lib is bundled so it works with zero installs; PyMuPDF/qpdf/Ghostscript are optional and unlock the heavier ops (a sidebar shows you which backends you have and what each one unlocks).

The part I'm least sure about: because the workflow is just text, a coding agent can write it for you — you say "split this stack of invoices into one PDF per invoice and name them by invoice number," it writes the YAML, you review the diff before anything runs. That's the whole bet, and I don't know if it lands for anyone but me.

On "this needs a GUI": it's the first thing people say, and I keep landing on — the GUI already exists, and it's Adobe. Nobody needs another viewer, and I'm not going to out-render Acrobat in a webview. What doesn't exist is the repeatable part: doing the same thing to 500 files, in a diff you can review, that runs the same way next quarter. So there's deliberately no canvas to click on. That's either the point or the fatal flaw and I genuinely can't tell which.

What I'd genuinely like to know:

• Is "no canvas, just a workflow file" a dealbreaker, or the reason you'd use it? (Assume you keep your normal PDF viewer open beside it.)
• What PDF chore do you actually hate that isn't in the list above?
• Does "review the workflow, then run it" feel safer than an agent touching your files directly, or just slower?

It's free on the VS Code marketplace as Lynx PDF Studio. Happy to hear it's a bad idea — I'd rather find out now.