标签：#vscode

If you've tried an "agentic" AI coding tool recently, there's a good chance it asked you to switch editors entirely. Google's own agent-first IDE, Antigravity, launched in November 2025 with exactly that trade-off: full agentic power, but only inside its own dedicated desktop application. That trade-off just went away. Google has shipped Antigravity extensions for VS Code, Visual Studio, JetBrains, and Zed , bringing the same agent, the same review workflow, and the same account into the editor you've already spent years configuring exactly the way you like it. This post walks through what the VS Code extension actually is, how it fits into Antigravity's broader architecture, how to install and configure it, and most importantly; how its permission system keeps an agent that can read files, run terminal commands, and drive a real browser from doing anything you haven't explicitly allowed. By the end of this article, you will be able to: Explain how the extension relates to the full Antigravity 2.0 desktop app and the agy CLI Install and authenticate the extension inside VS Code Work through the agent side panel, implementation plans, and walkthroughs Configure the permission engine so the agent only does what you approve Lock down its browser subagent so it never touches your personal Chrome data New to Antigravity generally? Start with Google's own primer: Antigravity 2.0 Overview Prerequisites To follow along hands-on, you'll need: VS Code version 1.90 or later, on macOS, Linux, or Windows A Google Account on any Antigravity plan (the free tier is enough), or an enterprise account enabled for Gemini Enterprise About five minutes for the first-time sign-in and backend install You can also read this purely as an architecture and workflow walkthrough; every step is explained, not just shown. 1. Where the Extension Fits in Antigravity's Architecture It helps to know there are actually three doors into the same house: [ Antigravity 2.0 ] ── the full desktop app, a dedi

Okay, story time. If you've worked on a full stack app where the backend is Java/Spring Boot and the frontend is React, you know the drill. Someone changes something on one side of a contract and nobody tells the other side. Weeks later you're playing detective across five files trying to figure out who calls what. And it's not just REST endpoints. It's the scheduled job that quietly writes to the same table your API touches. It's the service that calls another service, which calls another service. It's the Kafka event your controller publishes that some completely unrelated listener is consuming three modules away. All of that is "the contract" too, it's just invisible unless you go looking for it. Now add AI coding agents into that picture. They're great at writing code in the file they're looking at. They're not great at knowing that the component they're editing calls an endpoint, which hits a controller, which calls a service, which calls a repository, which is also written to by a scheduled job at 2am, which also fires an event three other services are listening for. Agents see one file at a time. So they'll happily rename a field or change a return shape on one side and leave everything downstream of it completely unaware anything changed. I got burned by this enough times that I decided to build the map myself. That's how Contour happened, and then, once I realized AI agents needed to query that map directly instead of just reading it off my screen, Contour MCP happened right after. Let's get into it. The actual problem Working across a UI, a REST API, a service layer, a repository layer, a database, plus schedulers and events sitting on top of all of it, two things go wrong constantly. Agents (and honestly, humans too) edit one side of a flow without knowing the other side exists. People burn real time reconstructing a call chain by hand, jumping through five or six files just to make a change that should be simple. Both come from the same root cause. Nobod

LaTeX is a document preparation system for high-quality typesetting, perfect for academic papers and technical docs. Many people turn to Overleaf as their go-to online editor for LaTeX, but it comes with its own frustrations. If you are tired of Overleaf being costly and always hitting the compile timed out error, this guide is for you! The full MacTeX install weighs in at a massive ~6.4GB, most of which you'll never actually use. Setting up a minimalist LaTeX environment on macOS using BasicTeX and VSCode is a much better alternative that makes your setup ~8 times smaller. It saves storage and makes it much easier to collaborate with your teammates using GitHub as a combo. Install LaTeX via Homebrew We'll use Homebrew to keep things manageable. If you don't have it, grab it at brew.sh . 1. Install LaTeX BasicTeX is the "lean" version of MacTeX. It's only ~140MB initially. brew install --cask basictex 2. Refresh your path and verify Make the TeX binaries available in your current terminal session: eval " $( /usr/libexec/path_helper ) " The default LaTeX compiler pdflatex should be available now. Verify it's working: which pdflatex pdflatex --version 3. Update tlmgr and packages tlmgr is the TeX Live Manager. To update tlmgr and all packages, run the following commands: sudo tlmgr update --self sudo tlmgr update --all 4. Install latexmk (build manager) latexmk is the "build manager" that handles multiple runs of the compiler (necessary for bibliographies and tables of contents). sudo tlmgr install latexmk Verify latexmk version: which latexmk latexmk --version 5. Install essential package collections BasicTeX is too bare-bones for real projects. Since we went minimalist, we need to grab only the packages we actually use. These three collections will cover 90% of your needs while keeping storage down. sudo tlmgr install collection-latexrecommended sudo tlmgr install collection-fontsrecommended sudo tlmgr install collection-latexextra Note: If a build fails due to a mi

A deep dive into the 3-way battle for the developer's desktop—comparing AI depth, flow state, autonomous agents, and real-world productivity. Three years ago, choosing a code editor was simple: you downloaded VS Code, installed your favorite syntax theme, added a few extensions, and got to work. Today, developer tooling has undergone a seismic shift. AI isn't just an extension sitting in a sidebar; it's driving entire workflows, editing dozens of files simultaneously, and executing complex engineering tasks. Enter the primary contenders dominating the developer landscape: VS Code (+ GitHub Copilot): The battle-tested industry titan with unmatched ecosystem depth. Cursor: The pioneer of the AI-native fork, built specifically for flow state and multi-file orchestration. Windsurf: Codeium's AI-first editor featuring autonomous flow state agents and deep context tracking. If you're trying to figure out which editor will give you or your engineering team the highest return on productivity, here is a practical, data-informed breakdown. The Architectural Divide: Plugins vs. AI-Native Forks Before comparing feature lists, it helps to understand the underlying architecture: VS Code remains an extension-first model. The core editor is unchanged, while GitHub Copilot operates alongside it as an assistant. Cursor and Windsurf are VS Code forks. Their creators modified the editor at an architectural level to give the AI direct access to your local workspace, terminal, file system, and git context. This distinction dictates how each editor feels when you're in the middle of a complex coding session. 1. Inline Autocomplete & Flow State When writing code line-by-line, friction is the enemy of productivity. Cursor Famous for its ultra-fast multi-line predictions. Cursor predicts not just the next token, but your next probable edit location across nearby lines. It keeps you in a continuous "flow state" where hitting Tab feels almost telepathic. Windsurf Features "Supercomplete" inlin

code-server is the open-source project that runs full VS Code including extensions, integrated terminal, Git, IntelliSense — on a remote server, accessible from any browser. This guide deploys it on Ubuntu 24.04 with Docker Compose, fronted by Traefik for automatic HTTPS. Prerequisites: an Ubuntu 24.04 server (1GB RAM / 2 vCPU minimum), a domain A record (e.g. code.example.com ), Docker and Docker Compose installed. Set Up the Project $ mkdir -p ~/vscode-server/ { project,config,local,letsencrypt } $ cd ~/vscode-server project — your editable workspace config — code-server settings/extensions local — user-specific data letsencrypt — Traefik's ACME certificate storage Find your UID/GID and add yourself to the docker group: $ id $USER $ sudo usermod -aG docker $USER Write the Compose File $ nano docker-compose.yml services : code-server : image : codercom/code-server:latest container_name : code-server user : " UID:GID" # Replace with your user's UID and GID environment : - PASSWORD=SECURE_PASSWORD # Replace with a strong password - DOCKER_USER=LINUXUSER # Replace with your username volumes : - ./project:/home/coder/project - ./config:/home/coder/.config - ./local:/home/coder/.local networks : - internal restart : unless-stopped labels : - " traefik.enable=true" - " traefik.http.routers.code-server.rule=Host(`CODE.EXAMPLE.COM`)" # Replace with your domain name - " traefik.http.routers.code-server.entrypoints=websecure" - " traefik.http.routers.code-server.tls.certresolver=myresolver" - " traefik.http.services.code-server.loadbalancer.server.port=8080" traefik : image : traefik:latest container_name : traefik ports : - " 80:80" - " 443:443" volumes : - /var/run/docker.sock:/var/run/docker.sock:ro - ./letsencrypt:/letsencrypt command : - " --providers.docker=true" - " --providers.docker.exposedbydefault=false" - " --providers.docker.network=internal" - " --entrypoints.web.address=:80" - " --entrypoints.websecure.address=:443" - " --entrypoints.web.http.redirections.entr

tinyNpm is a vs code extension that helps protect you from supply chain attacks, stale packages, and bloated code! I had been using package.json version keepers for quite some time but after the big supply chain attack i thought they would be the perfect place to add in some security. The idea is just to provide the latest package number x days old. This will help prevent most of the danger in supply in chain attacks. It will also remove the ^ if you have it so you can better control what version of a package your application is using. To be more security focused it gives general hints in the hover menu to help keep an eye on the packages you have installed. These hints include warnings for staleness, high dependency count, and number of downloads. Since all of this is something you can get through the npm api, I called it tinyNpm You can download it on the marketplace

Tired of squinting at VS Code’s stacked merge editor? MergeForge brings a JetBrains-style three-pane conflict resolver to VS Code and Cursor — and pairs it with an AI assistant that actually reads your repository before it suggests a fix. The problem We’ve all been there. You’re halfway through a rebase. Git stops. Twelve files are conflicted. You open one in VS Code… and get that familiar stacked layout: Incoming, Current, and a result pane that somehow still feels like a puzzle with half the pieces missing. If you ever used WebStorm or IntelliJ, you know how good merge tools can feel: Your side on the left Their side on the right The result in the middle Gutter arrows that just… work In VS Code land, that flow never quite arrived. You click Accept Current, Accept Incoming, Accept Both, and hope nothing important got flattened. Word-level diffs? Authorship? A clear “who wrote this chunk?” signal? Often missing when you need them most. And when AI entered the chat, a lot of tools treated conflicts like isolated text blobs: “Here are the <<<<<<< markers. Good luck.” But real merges need context. What was the branch trying to do? What does the surrounding file look like? Who touched this last? Without that, “AI resolve” is just confident guessing. I wanted the JetBrains merge experience — inside VS Code and Cursor — with an assistant that behaves more like a careful teammate than a slot machine. So I built it. The solution: MergeForge MergeForge is an open-source VS Code / Cursor extension that turns conflicted files into a proper three-pane visual merge. Layout: Left Center Right Yours (local) Result (editable, seeded from the merge base) Theirs (incoming) Panes scroll together. Chunks connect with bands. Gutter controls let you accept, ignore, or blend sides without fighting the UI. When you’re done, Apply writes the result and stages it with git. If you prefer Cursor, you’re covered too. The editor works the same; for AI features you plug in your own provider key (

I created the official PasteDB VS Code extension that lets you upload your current file or selected code directly from Visual Studio Code. It includes secure API key storage, customizable upload settings, recent paste history, automatic language detection, and instant shareable links. In this post, I'll explain how it works, how to install it, and the challenges I faced while building it. More Info View on Marketplace

As developers , we often face challenges keeping our workspaces perfectly synchronized across devices and collaborators. Whether it’s dealing with slow cloud sync, merge conflicts, or latency issues, these problems can disrupt our workflow and productivity. That’s why I’m excited to introduce OrBit , a local-first workspace synchronization engine designed to keep your development environments in sync with sub-millisecond latency — all while supporting offline work and peer-to-peer collaboration. What is OrBit ? OrBit is built around a multi-layered architecture that combines the power of Rust, Tauri, and VS Code to deliver a seamless synchronization experience: Rust-based local watcher daemon: Monitors file system changes with kernel-level events for ultra-low latency. Tauri-based native desktop dashboard: Provides a lightweight, secure, and cross-platform interface to manage your sync settings. VS Code extension: Integrates directly with your editor for smooth, real-time syncing of your code workspace. Unlike traditional cloud-based sync solutions, OrBit uses peer-to-peer connections and Conflict-free Replicated Data Types (CRDTs) to ensure your workspaces stay consistent even during network partitions or offline periods. Key Features Real-time sync with sub-millisecond latency: Changes propagate instantly across your devices. Offline support: Work uninterrupted without internet, with automatic merging when reconnected. Conflict resolution: CRDTs handle concurrent edits gracefully, preventing data loss. Native desktop and editor integration: Manage sync easily via the desktop app and VS Code extension. Peer-to-peer architecture: No heavy cloud servers required, enhancing privacy and speed. Why OrBit ? OrBit is designed for developers who demand speed, reliability, and seamless collaboration. It eliminates the frustration of slow syncs and merge conflicts, letting you focus on coding. Whether you’re working solo across multiple devices or collaborating with a team,

We have all been there: you open your editor to write a simple feature, and within ten minutes, your screen is a chaotic mess. You are drowning in squiggly red lines, bright rainbow bracket lines, a crowded sidebar, Git blame popups blocking your text, and terminal notifications screaming for attention. Modern IDEs like VS Code and Cursor are incredibly powerful, but out of the box, they are built to distract you. If you want to achieve true flow state, you need to strip away the noise. Here are 10 minimalist extensions built for both VS Code and Cursor that are explicitly engineered to eliminate clutter, reduce cognitive load, and help you focus on the only thing that matters: the code. Interface and Zen Mode Cleansers 1. Zen Mode (Built-in, but needs tweaking) The Vibe: Complete visual isolation. What it does: While not an external extension, true minimalism starts here. Hitting Cmd+K Z (or Ctrl+K Z) instantly hides the activity bar, status bar, sidebar, and editor tabs, leaving you with nothing but your code centered on the screen. The Focus Trick: Go into your settings and toggle zenMode.hideLineNumbers to true to get rid of the left-hand numbering margin entirely for deep reading sessions. 2. APC Customize UI++ The Vibe: Pixel-perfect control over editor bloat. What it does: If you love the layout of hyper-minimalist editors like Zed but want to keep the power of Cursor or VS Code, this is your holy grail. It allows you to shrink font sizes of the UI independently from your code, hide specific layout borders, trim the massive top title bars, and customize panel padding to give your code room to breathe. 3. Customize UI / Active Bar Hidden The Vibe: Moving target elements out of sight. What it does: The left-hand Activity Bar (with the extensions, search, and source control icons) is a constant source of colorful badge notifications. Use this to hide it entirely. You can easily trigger those panels via keyboard shortcuts (Cmd+Shift+E for explorer, Cmd+Shift+F fo

GA in a sentence GitHub moved its enterprise managed-settings.json to general availability on July 1, giving GitHub Enterprise Cloud admins a single JSON file that overrides Copilot behaviour in VS Code and Copilot CLI for anyone holding a Copilot Business or Copilot Enterprise seat issued from the enterprise or one of its organizations. The changelog frames it as a place to define AI standards for the tenant. In practice it is a supported home for Copilot policy that shipped one setting at a time in beta up to this point. The five keys the file accepts Five keys are documented at GA: extraKnownMarketplaces , enabledPlugins , strictKnownMarketplaces , disableBypassPermissionsMode , and model . Together they configure trust for extra plugin marketplaces, the enabled-plugins list, strict enforcement of the known-good marketplace list, whether Copilot CLI and the VS Code extension can run in bypass-permission mode, and which model a user is allowed to pick. Value shapes are not enumerated in the changelog itself; the docs page is the reference for the schema. How the file reaches a client The file lives at copilot/managed-settings.json inside the .github-private repository of the organization the enterprise nominates for the role. There is a backward-compatible path at .github/copilot/settings.json for tenants already using the older layout. Copilot clients fetch the file from the server on every authentication, hold it in memory, and refresh it hourly, per the changelog. That server-side file takes precedence over the file-based config a user may have on their own machine. Setup runs through the AI Controls tab in enterprise settings, or the equivalent API endpoint, where an admin picks the hosting organization. Anyone who followed the June rollouts of disableBypassPermissionsMode and strictKnownMarketplaces will recognise the same file and the same repo. GA is what turns the plumbing into a supported product surface. Where it will trip you Two operational details are

If you are still using a vanilla installation of VS Code, you are leaving massive amounts of productivity on the table. We all know the standard extensions: Prettier, ESLint, GitLens. But what about the tools that actually change how you write code? Here are 7 hidden VS Code extensions that feel almost illegal to use because of how much time they save. 1. Error Lens Stop hovering over red squiggly lines. Error Lens highlights the entire line and prints the error message inline, right next to your code. You instantly know what is wrong without moving your mouse. Once you install this, you will never be able to code without it again. 2. Console Ninja Tired of switching back and forth between your browser console and your editor? Console Ninja prints console.log output and runtime errors directly in your editor, right next to the line of code that triggered it. It is like magic. 3. Turbo Console Log Highlight a variable, press Ctrl+Alt+L , and this extension automatically inserts a perfectly formatted console.log statement with the variable name and its value. It saves you hundreds of keystrokes a day. 4. Mintlify Doc Writer Writing documentation sucks. Mintlify uses AI to instantly generate beautiful, accurate JSDoc/Python docstrings for your functions. Just highlight the function and hit a button. 5. CSS Peek If you work with large HTML or React files, CSS Peek allows you to hover over a class name and instantly see (and edit) the CSS attached to it in a floating window. No more hunting through massive .css files. 6. Code Spell Checker There is nothing worse than pushing a PR and having a senior developer point out a typo in a variable name. This extension highlights spelling errors in your code, keeping your codebase looking professional. 7. WakaTime Do you actually know how much time you spend coding? WakaTime generates beautiful dashboards showing exactly which languages, projects, and files you spent your time on each week. It is incredible for tracking your own

Most teams still treat manual test cases as rows in a SaaS database. That worked when cases were written slowly, reviewed rarely, and automation lived in a separate silo. It works less well now. AI can draft cases from screenshots and user stories in minutes. Automation lives next to application code. QA and dev share the same PRs. Auditors ask where test data lives and who changed what. In that world, test cases are data — and the format you choose matters as much as the tool UI. The durable direction is tests as code : plain YAML files in version control, with a thin local layer for humans to browse, run, and review. Not because databases are evil, but because git + YAML matches how we already work with code, AI, and compliance. 1. AI is good at YAML — and YAML keeps your data yours LLMs are unusually good at structured text: YAML front matter plus a Markdown body is a sweet spot. Give the model a schema ( title , tags , priority , steps, expected result) and a screenshot or user story, and you get a draft case in one pass. That matters for more than speed: Boundary cases — ask the model what you might have missed; it can reason about the scenario, not just paraphrase the story. Consistency — the same format every time makes batch generation and review predictable. The deeper point is data ownership . Cases in a vendor DB are convenient until they are not: export limits, API friction, another system to secure, another place sensitive scenarios live. Local YAML in your repo is trivial for AI to read (including Cursor, Copilot, or whatever you use next), diff, and update — without shipping your test catalog to a third party. For many teams, that is a real security and efficiency win — not ideology. 2. Manual YAML beside automation makes coverage measurable When manual cases and automated tests sit in the same repository, a few things become boring in a good way: Tag a case automated: true and point params at a Playwright or Selenium path — one file, one id. Automati

Many Python beginners can write basic programs but get stuck when they try to run a real project on their own laptop. The issue is not always coding. Sometimes the real problem is setup . You may know loops, functions, and lists, but still face problems like: ModuleNotFoundError Python is not recognized Package installed but not working in VS Code Wrong interpreter selected These are common beginner setup issues. Why online compilers are not enough Online compilers are good for quick practice. But real Python projects need: project folders multiple files external packages virtual environments dependency files terminal commands debugging tools Git basics So, when the goal is to build real projects, it is better to move to a local Python setup early. Basic Python project setup flow A simple Python project setup flow looks like this: Install Python Install VS Code Create project folder Create virtual environment Activate virtual environment Install packages Save requirements.txt This setup may look basic, but it prevents many beginner-level errors later. Example folder structure A beginner-friendly Python project folder can look like this: python-project/ │ ├── main.py ├── requirements.txt ├── README.md └── venv/ Here is what each file or folder means: main.py is the main Python file. requirements.txt stores project dependencies. README.md explains the project. venv/ contains the virtual environment. Create a virtual environment Create a virtual environment using: python -m venv venv Activate it on Windows: venv \S cripts \a ctivate Activate it on Mac/Linux: source venv/bin/activate A virtual environment keeps each project’s packages separate. This helps avoid package conflicts when working on multiple Python projects. Install a package After activating the virtual environment, install packages using pip . Example: pip install requests Now create a Python file: import requests response = requests . get ( " https://api.github.com " ) print ( response . status_code ) If

Feeling overwhelmed by the constant flood of new AI features, MCP servers, and agentic platforms? In a world full of tech noise, it's easy to get exhausted trying to keep up. I just watched an incredible video by Burke Holland where he strips away the hype and shares 10 highly practical, concrete strategies to make AI coding tools actually work for your daily workflow. If you want to stop overcomplicating your setup and start getting better production results, here is the ultimate breakdown. The 10 AI Coding Tips (TL;DR Summary) Huge shoutout and credit to Burke Holland for these insights: 1) Use Visual Studio Code to maximize your environment with powerful themes, extensions, and inline terminal chats. 2) Always turn on YOLO / "allow all" mode so your AI agent can execute commands seamlessly without breaking your flow with constant permission prompts. 3) Never run agents on your own machine , choosing instead to isolate them via remote SSH or dev containers so YOLO mode is completely safe. 4) Prototype and mock everything upfront to map out UI design languages and logic before implementing code. 5) Always plan and grill by leveraging interactive planning modes to answer critical edge-case questions before generating file. 6) Rubber duck your plans across different AI model families (like combining Claude and GPT) to cross-verify solutions and expose blind spots. 7) Utilize autopilot and sub-agents to delegate parallel tasks and route smaller, faster models where appropriate. 8) Use built-in browser tools to visually review live previews and directly prompt structural or stylistic adjustments. 9) Run iterative multi-model reviews on autopilot to catch hidden bugs and refine code quality until reaching a clear point of diminishing returns. 10) Learn from your session history using tools like Chronicle to analyze your prompting habits and continually optimize how you interact with the agent. 📚 Recommended Reading If you are looking to dive deeper into perfecting your

Đối với một developer, trackpad không chỉ là thiết bị điều hướng mà còn là công cụ tối ưu hóa workflow. Khi làm việc với các IDE nặng như VS Code hay IntelliJ, khả năng phản hồi của trackpad quyết định tốc độ xử lý tác vụ. Trong bài so sánh giữa ROG Zephyrus G14 GA403 hay MSI Creator 16 AI? Đâu là lựa chọn cho sáng tạo chuyên nghiệp? , trải nghiệm trackpad là một điểm nhấn quan trọng. Trải nghiệm cử chỉ và độ chính xác trong lập trình Khi làm việc với code, các cử chỉ như chuyển đổi desktop ảo (Virtual Desktops) là cực kỳ quan trọng để tách biệt môi trường chạy Docker, trình duyệt và editor. Vuốt 3-4 ngón: Cả hai dòng máy đều hỗ trợ tốt, nhưng trên MSI Creator 16 với diện tích lớn hơn, việc nhận diện cử chỉ vuốt ngang giữa các workspace mượt mà hơn đáng kể. Độ chính xác chọn văn bản: Với một developer, việc bôi đen một đoạn code dài hoặc chọn chính xác một ký tự nhỏ là yếu tố sống còn. Trackpad trên G14 có độ nhạy cao nhờ kích thước gọn nhẹ, trong khi Creator 16 cho cảm giác vững chãi, ít bị trượt hơn khi thao tác nhanh. Độ trễ (Latency): Cả hai đều đạt chuẩn cao, tuy nhiên trên Windows, trải nghiệm đôi khi không mượt bằng macOS. Để khắc phục, việc sử dụng driver tùy chỉnh là cần thiết. So sánh hệ điều hành và mẹo cấu hình cho Developer Trải nghiệm trackpad thay đổi rõ rệt giữa Windows và Linux : Windows: Hỗ trợ tốt Precision Drivers. Bạn nên vào Settings > Bluetooth & devices > Touchpad để tinh chỉnh độ nhạy.\n- Linux: Nếu bạn dùng Ubuntu hay Fedora, hãy cài đặt libinput . Để tối ưu hóa cho workflow code, bạn có thể cấu hình file .wslconfig nếu chạy môi trường Windows Subsystem for Linux nhằm đảm bảo tài nguyên không bị nghẽn khi thao tác giao diện.\n Thông số kỹ thuật tóm tắt: ROG Zephyrus G14 GA403: Ryzen 9 8945HS, RTX 4070, 32GB LPDDR5X, OLED 14" 120Hz, nặng 1,5 kg. MSI Creator 16 AI Studio: Core Ultra 9 185H, RTX 4080/4090, lên đến 64GB DDR5, Mini LED 16" 120Hz, nặng 2,1-2,5 kg. Bài viết này là bản tóm tắt kỹ thuật. Xem chi tiết tại bài gốc.

I used to think a serious developer needed a serious IDE. Big project? Open PhpStorm. Design work? Open Photoshop. Need every refactor, every inspection, every plugin, every panel, every button? Load the heavy tool and wait for the machine to breathe again. But something changed. Not overnight, and not because those tools suddenly became bad. They are still powerful. The change is that AI started taking over the parts of the IDE I actually needed most. Today, I spend more time in VS Code and the terminal than in heavy IDEs. My machine feels lighter. My workflow feels less crowded. And honestly, I do not miss the old setup as much as I thought I would. The old IDE was a safety net For years, big IDEs won because they could see the whole project. They understood symbols, imports, frameworks, database models, refactors, formatting, inspections, and tests. A good IDE felt like a senior assistant sitting beside you, quietly warning you before you made a mess. That was valuable. It still is. But AI has started to move that intelligence out of the IDE shell. The useful part is no longer tied to one huge application. It can live in your editor, your terminal, your pull request, your CI pipeline, or even in a chat window with access to your codebase. When AI can read the files, reason about the bug, generate a test, run the test, inspect the failure, and propose a patch, the IDE becomes less like the brain of the workflow and more like one possible place to type. AI is becoming the environment The phrase "AI coding assistant" already feels too small. Autocomplete was the first version. The newer pattern is closer to an AI developer environment. You ask it to find the bug. It searches the repo. You ask it to explain a weird error. It follows the stack trace. You ask it to write a benchmark. It can create the benchmark file, run it, compare the result, and tell you what changed. You ask it to add tests. It can inspect the code path and generate cases you probably would have de

You're about to install a VS Code extension. Maybe it's a formatter, a linter, a theme, an AI tool....

There's a pattern I've noticed with every new AI coding tool that comes out: they all want you to switch editors. Or open a new terminal. Or context-switch into some standalone app. I DON'T WANT TO DO THAT My entire dev workflow lives in VS Code. My keybindings, my split panes, my snippets, my extensions — all of it. When Google released the Antigravity CLI ( agy ), an agentic coding assistant, I genuinely liked what it could do. But to use it properly, I had to live in a terminal window, manually managing sessions, typing slash commands from memory, and losing my editor context entirely. So I built a VS Code extension for it instead. What is Antigravity? Google Antigravity is Google's agentic coding CLI — think of it as a Gemini-powered dev assistant that can read your project, run tools, execute terminal commands, and help you build. It's the kind of tool that can handle complex multi-step tasks, not just autocomplete. The CLI is called agy , and it's genuinely capable. The problem was the workflow: terminal-first, session management by hand, and no visual layer over the context you're already in. The Extension: Antigravity for VS Code Install it on the VS Code Marketplace Source on GitHub The core idea is simple: the extension is a UI layer. It never bundles or replaces the agy binary — it shells out to whichever version you have installed locally. Same philosophy as the Claude Code VS Code extension: the editor provides the surface, the CLI does the work. Here's what it actually does: Sessions List The sidebar panel opens to all your saved sessions. You can open an existing one, delete it, or start fresh. New sessions can be launched in sandboxed mode or with permissions bypassed — accessible right from the "New Session" overflow menu, without memorizing CLI flags. Any session with an active turn shows a loading indicator in its row, so you always know what's in flight. Chat Panel (Material 3 Expressive) This is the main surface. Each session runs its own live,

Most apps don't just call one API endpoint. They call a whole chain of them. For example, you might log in, get a token, and then pass that token to another service. Tracking these multi-step chains can get messy quickly. To help fix this, the OpenAPI Initiative created the Arazzo Specification . It gives us a standard way to link different endpoints into clear workflows. But writing these workflow files by hand in a regular text editor is tough. It is very easy to lose track of how data moves from one step to the next. That is why I built Arazzo Visualizer for VS Code. It is a free, open-source extension that makes the Arazzo spec visual and easy to use. Live Interactive Graphs The extension reads your workflow files and turns them into interactive maps on the fly. See Data Flow: Look at exactly how data moves between steps. Catch Errors Early: Spot broken paths before you even run your code. Clean Layouts: Navigate large workflows without getting lost in thousands of lines of text. Built-In Workflow Runner Seeing the map is great, but testing it is even better. The tool has a step-by-step runner built right into your editor. Run a single step or execute the whole chain. See real-time data payloads and HTTP headers. Watch requests happen live to pinpoint bugs fast. Give it a Try The project is fully open source, and you can grab it or check out the code using the links below: Download: Install it directly from the VS Code Marketplace . Source Code: Check out the repository, report bugs, or contribute on GitHub . Deep Dive: Read my full technical breakdown and design on Medium . If you are working with API chains, I would love for you to try it out. Drop your feedback in the comments below! Note: Arazzo v1.1.0 is out with official AsyncAPI support. I am currently updating the VS Code extension to support these new features. Stay tuned for future updates!