VScode claude code plugin. Can I check how this integrates, and why the same isn't happening when I want to work with local models?

• Original author switched from VSCode to Zed in December and now uses Zed as the primary editor for Python and Go.
• Main reason for leaving VSCode was increasingly intrusive AI features (Copilot prompts, inline terminal suggestions) and perceived increase in crashes and slowness.
• Author still likes VSCode overall but feels rapid AI integration harmed stability and usability, and hopes it becomes less intrusive in the future.
• JetBrains IDEs were rejected as feeling too heavy, and Vim/Emacs as too time‑intensive to configure; Zed was attractive as a modern, lightweight Rust-based IDE.
• Transition from VSCode was smooth: similar UI, mostly compatible keybindings, and ability (unused by author) to import some VSCode settings.
• Zed felt significantly faster and more responsive than VSCode, with no glitches or crashes over a couple of weeks, restoring a sense of “joy of programming”.
• Initial Zed setup was minimal: adjust fonts, theme, disable inline git blame, and enable autosave; Go worked out of the box.
• Python setup required more work because Zed uses language servers and defaults to Basedpyright instead of Pylance (which is VSCode-only and closed source).
• The author hit unexpected strict type-checking because projects with a [tool.pyright] section in pyproject.toml effectively force Basedpyright’s recommended mode.
• Attempting to set typeCheckingMode in Zed’s settings.json did not help; the fix was explicitly setting typeCheckingMode = "standard" inside each project’s [tool.pyright] config.
• Another issue was delayed type diagnostics across files, fixed by setting "disablePullDiagnostics": true in Zed’s Basedpyright initialization options.
• Virtualenv handling and other Python-specific behavior worked smoothly; the author also tried the new ty language server, found it good, but stayed with Basedpyright to match CI’s Pyright.
• Zed is now the author’s default IDE: fast, stable, familiar, with enough extensions despite a much smaller ecosystem than VSCode.
• The main missing feature is a powerful side‑by‑side git diff viewer comparable to GitLens.
• Zed’s AI features are present but easy to ignore; paid plans for AI edit predictions seem like a reasonable way to fund development while keeping the core editor free.
• The author views Zed as a serious competitor that pressures VSCode to improve, especially around AI integration and performance.
• The post ends with sharing a minimal settings.json showcasing autosave, disabled inline blame, VSCode keymap, fonts, light theme, and customized Basedpyright LSP options.

Hacker News Discussion

• A VS Code team member acknowledges that AI-related features sometimes ignore the “disable” settings but states they try to ship fixes quickly and appreciate feedback.
• Several commenters recommend VSCodium as a way to get the open‑source VS Code experience without Microsoft’s telemetry and aggressive AI integration, while clarifying that both VS Code and VSCodium build from the same upstream repo.
• Many users express frustration with VS Code becoming bloated, unreliable, or “enshittified,” particularly around Copilot and complex configuration/remote setups, and are looking at Zed or classic editors as alternatives.
• Emacs and Vim/Neovim advocates argue that investing in these longstanding editors avoids churn and AI/UX regressions, with some describing decades-long Emacs usage and others praising Neovim plus LSPs as a lightweight yet powerful setup.
• Sublime Text is often cited as the spiritual predecessor of Zed in terms of speed and snappiness, with some saying Zed is the closest modern successor focused on performance.
• Zed users highlight positives like fast AI/MCP integration, good Nix/Direnv support, and pleasant design, but note pain points such as font rendering on low‑DPI or non‑GPU setups, Linux packaging gaps, missing REPLs for Lisps, and weaker debugging/extension ecosystems compared to VS Code or JetBrains.
• Some comments mention concrete bugs and annoyances in Zed, including format‑on‑save occasionally deleting the first line of Python classes, unwanted newline insertion at EOF, and missing small quality-of-life features (e.g., indentation autodetection, drag‑and‑drop markdown link insertion).
• A few developers describe hybrid workflows: using JetBrains IDEs on powerful machines, Zed on lower‑power devices, and Vim/Neovim or Sublime for quick one‑off edits, emphasizing that Zed is not yet at JetBrains’ level for deep refactoring and code understanding.
• Several participants discuss Zed’s business model as an AI “reseller”: core editor remains free while Pro users pay for pooled tokens across multiple AI providers, which some see as a relatively benign and sustainable way to monetize.
• There is concern that Zed’s extension ecosystem is still small and that Rust-based extension development may limit growth relative to VS Code; suggestions include better guidance for porting VS Code extensions and addressing collaboration/chat self‑hosting and security concerns.

Obsidian MCP not found in VS Code market.

VS Code acts as MCP Host (in their AI toolkit extension I think). You could connect it to the Obsidian MCP server plugin then?

A comparison between VS Code and Obsidian. Doesn't state the obvious: any text editor can do this. The tools are just viewers and do not contain the data, which is part of your filesystem. Vgl [[3 Distributed Eigenschappen 20180703150724]]

The AI toolkit adds LLM based options to VSCode. Installed it, as it allows me to access different models via ollama locally.

Claude Code plugin for Visual Studio Code

vscode + latex workshop，syntex 跳转：在编辑窗格中，用 ctrl+alt+j；在预览窗格中，用 ctrl+左键

Sample .devcontainer/devcontainer.json:

json { "name": "Global", "build": { "context": "..", "dockerfile": "Dockerfile" }, "containerEnv": { "PYTHONPATH": "." }, "customizations": { "vscode": { "settings": { "extensions.verifySignature": false }, "extensions": [ "GitHub.copilot", "ms-python.vscode-pylance", "ms-python.python", "eamodio.gitlens" ] } }, "initializeCommand": "/bin/bash -c '[[ -d ${HOME}/.aws ]] || { echo \"Error: ${HOME}/.aws directory not found.\"; exit 1; }; [[ -f ${HOME}/.netrc ]] || { echo \"Error: ${HOME}/.netrc file not found.\"; exit 1; }; [[ -d ${HOME}/.ssh ]] || { echo \"Error: ${HOME}/.ssh directory not found.\"; exit 1; }; echo \"\n> All required mounts found on the host machine.\"'", "onCreateCommand": { "hadolint": "apt-get update && apt-get install wget -y && wget -O /bin/hadolint https://github.com/hadolint/hadolint/releases/download/v2.12.0/hadolint-Linux-x86_64 && chmod u+x /usr/bin/hadolint", "precommit": "pip install pre-commit" }, "updateContentCommand": "/bin/bash -c 'if grep -A 2 \"machine gitlab.com\" ~/.netrc | grep -q \"password\" && GITLAB_TOKEN=$(grep -A 2 \"machine gitlab.com\" ~/.netrc | grep -oP \"(?<=password ).*\" | tr -d \"\\n\") && [ -n \"$GITLAB_TOKEN\" ]; then echo \"\n> Token found in ~/.netrc\"; else read -sp \"\n> Enter your GitLab token: \" GITLAB_TOKEN && echo; fi; echo \"export GITLAB_TOKEN=$GITLAB_TOKEN\" >> ~/.bashrc && . ~/.bashrc && poetry config http-basic.abc __token__ $GITLAB_TOKEN'", "postCreateCommand": ". ~/.bashrc && curl -s --location 'https://gitlab.com/api/v4/projects/12345/repository/files/.pre-commit-config.yaml/raw?ref=main' --header \"PRIVATE-TOKEN: $GITLAB_TOKEN\" -o .pre-commit-config.yaml", "postAttachCommand": "/bin/bash -c '. ~/.bashrc && read -p \"\n> Do you want to update the content of devcontainer.json? (y/n): \" response; if [[ \"$response\" == \"y\" ]]; then curl -s --location \"https://gitlab.com/api/v4/projects/12345/repository/files/devcontainer.json/raw?ref=main\" --header \"PRIVATE-TOKEN: $GITLAB_TOKEN\" -o .devcontainer/devcontainer.json; else echo \"\n> Skipping update of devcontainer.json\"; fi'", "mounts": [ "source=${localEnv:HOME}/.aws/,target=/root/.aws/,type=bind,readonly", "source=${localEnv:HOME}/.netrc,target=/root/.netrc,type=bind,readonly", "source=${localEnv:HOME}/.ssh/,target=/root/.ssh/,type=bind,readonly" ] }

Some more of my recent learning with devcontainer.json (its Dev Container metadata):

• Interactive commands (those waiting for user input like read) do not display the input request in (at least onCreateCommand and postCreateCommand sections), so it is better to keep them in updateContentCommand or postAttachCommand.
• If there are 2 read commands in a single section, like updateContentCommand, only the 1st one is displayed to the user, and the 2nd one is ignored.
• When I put a read command within a dictionary (with at lest 2 key/values) of postAttachCommand, the interactive command wasn't being displayed.
• We need to use /bin/bash -c to be able to use read -s (the -s flag) which allows for securely passing the password so that it does not stay in the VS Code console. Also, I had trouble with interactive commands and if statements without it.
• Using "GITLAB_TOKEN": "${localEnv:GITLAB_TOKEN}" does not easily work as it is looking for GITLAB_TOKEN env variable set locally on our host computers, and I believe no one does it.
• The dictionary seems to be executing its scripts in parallel; therefore, it is not easily possible to break down long lines which have to execute in a chronological sequence.
• JSON does not allow for human-readable line breaks; therefore, indeed, it seems impossible to improve the long one-liners.
• The files/folders mentioned within mounts need to exist locally (otherwise, Docker container build fails). They are mounted before any other section. Technically, we can protect ourselves with the following command to find an extra message in VS Code container logs:

json "initializeCommand": "/bin/bash -c '[[ -d ${HOME}/.aws ]] || { echo \"Error: ${HOME}/.aws directory not found.\"; exit 1; }; [[ -f ${HOME}/.netrc ]] || { echo \"Error: ${HOME}/.netrc file not found.\"; exit 1; }; [[ -d ${HOME}/.ssh ]] || { echo \"Error: ${HOME}/.ssh directory not found.\"; exit 1; }'",

Other option is to get rid of the error completely, but this creates files on the host machine; therefore, it is not an ideal solution:

json "initializeCommand": "mkdir -p ~/.ssh ~/.aws && touch ~/.netrc",

I would also simply put the following:

bash /bin/bash -c 'read -p 'Type a message: ' -t 10 && echo Attach $REPLY'

I also found that updateContentCommand allows for the user interaction (it displays interactive command in the VS Code console).

Explanation of 6 available devcontainer.json (Dev Container in VS Code) hooks.

This is in the contributes part of the package.json

json "contributes": { "configuration": { "type": "object", "title": "Example configuration", "properties": { "languageServerExample.maxNumberOfProblems": { "scope": "resource", "type": "number", "default": 100, "description": "Controls the maximum number of problems produced by the server." }, "languageServerExample.trace.server": { "scope": "window", "type": "string", "enum": [ "off", "messages", "verbose" ], "default": "off", "description": "Traces the communication between VS Code and the language server." } } } },

输入 code-runner

It seems like VS Code offers a better way to manage Docker containers

定位文档路由和位置

Simple difference between two core debugging modes: Launch and Attach available in VS Code.

Depending on the request (attach or launch), different attributes are required, and VS Code's launch.json validation and suggestions should help with that.

Logpoints - log messages to the console when breakpoint is hit.

Can include expressions to be evaluated with {}, e.g.:

fib({num}): {result}

(animation)

Optional arguments for launch.json:

• presentation ("order", "group" or "hidden")
• preLaunchTask
• postDebugTask
• internalConsoleOptions
• debugServer
• serverReadyAction

In the launch.json file you've to define at least those 3 variables:

• type (e.g. "node", "php", "go")
• request ("launch" or "attach")
• name (name to appear in the Debug launch configuration drop-down)

Some of the possibly supported attributes in launch.json:

• program
• args
• env
• cwd
• port
• stopOnEntry
• console (e.g. "internalConsole", "integratedTerminal", "externalTerminal")

To easily see all the refactoring options, use the "Refactor" command

Customising settings for debugging tests while running

Python: Debug All Tests

or

Python: Debug Test Method

Debugging tests themselves

1. Set a breakpoint on the first line of the failing function (e.g. test_decrement)
2. Click the "Debug Test" option above the function
3. Open Debug Console and type: inc_dec.decrement(3) to see what is the actual output when we use x=3
4. Stop the debugger and correct the tests
5. Save the test file and run the tests again to look for a positive result

pytest displays failed tests also in PROBLEMS

Another way to view the test results:

View > Output > Python Test Log

Test Explorer is activated after discovering tests in Python:

After using python.testing.autoTestDiscoverOnSaveEnabled, it'll be set to true and discovering tests whenever a test file is saved.

If discovery succeeds, the status bar shows Run Tests instead:

Start testing in VS Code by using Python: Configure Tests (it automatically chooses one testing framework and disables the rest).

Otherwise, you can configure tests manually by setting only one of the following to True:

• python.testing.unittestEnabled
• python.testing.pytestEnabled
• python.testing.nosetestsEnabled

To run cells inside a Python script in VSCode, all you need to is to define Jupyter-like code cells within Python code using a # %% comment:

# %%
msg = "Hello World"
print(msg)

# %%
msg = "Hello again"
print(msg)

If you wish to use Java inside VSCode, try downloading the Installer of Visual Studio Code for Java developers

After creating a new project related environment, it shall be specified as a default for this specific project

Try to use logpoints instead of print statements.

More info: https://code.visualstudio.com/docs/editor/debugging#_logpoints

VS Code consumes much more memory in comparison to Sublime while working on more significant projects