Claude Code vs LM Studio vs VS Code: Managing Markdown Notes on Windows

In a hands-on test published by XDA Developers on October 17, 2026, writer Nolen Jonker explored what happens when you bypass traditional note-taking interfaces and point everyday developer utilities at a folder of plain-text Markdown notes. Instead of running a rigid benchmark, Jonker bent three distinct tools already running daily on a desktop—Anthropic's Claude Code, a local large language model running in LM Studio with a filesystem Model Context Protocol (MCP) server, and a stock installation of Microsoft Visual Studio Code without AI extensions—into note managers to see which workflow could actually handle the administrative burden of a personal knowledge base.

The takeaway from that experiment is not that one utility replaces every part of a note-taking app, but rather that capturing, reading, and organizing text files are fundamentally different jobs. When you strip away the marketing polish of productivity software and treat a vault for what it actually is—a directory of .md files—you uncover a fascinating split between raw editor speed, local hardware limits, and cloud-backed agentic automation.

Why Developer Tools Are Invading the Note Vault​

If you use an Obsidian vault or a Markdown folder on Windows 11, your notes are not locked inside a proprietary database. They are just text files sitting in standard directories. That architectural simplicity is the exact reason developer tools can step in without friction. Code editors and command-line agents are purpose-built to parse directory trees, grep for keywords across thousands of lines, track single-character diffs, and manipulate syntax structures.

Yet applying these tools to personal notes exposes a divide in how we interact with information:

• Browsing and Retrieval: Finding a specific phrase from six months ago and reading it cleanly.
• Quick Capture: Dumping a half-baked thought into a daily log before it evaporates.
• Vault Administration: Filing notes into the right subfolders, applying frontmatter properties, weaving wikilinks between related concepts, and pruning dead links.

Most users abandon their note systems because the third category—administration—feels like unpaid data-entry work. Testing an agentic CLI, a local LLM harness, and a classic code editor side by side reveals just how differently each architecture handles that chore.

Claude Code Plus Obsidian Skills: The Automated Librarian​

The clear winner for hands-off organization in the XDA Developers test was Claude Code, Anthropic's agentic coding tool that operates directly inside a local PC folder. Because an Obsidian vault is simply a directory of plain-text files, Claude Code can read and write notes inside it right out of the box.

To keep the agent from writing generic Markdown that ignores Obsidian's conventions, Jonker installed the official Obsidian skills pack published by Obsidian CEO Steph Ango. According to the public GitHub repository kepano/obsidian-skills, these agent skills follow the Agent Skills specification and work with compatible agents including Claude Code, Codex, and OpenCode. Specifically, the repository provides an obsidian-markdown skill for Obsidian Flavored Markdown (covering wikilinks, embeds, callouts, and properties), alongside skills for Obsidian Bases (.base), JSON Canvas (.canvas), the Obsidian CLI, Defuddle web extraction, and Knap template rendering. For Claude Code users, the repository instructs placing its contents into a /.claude directory at the root of the vault or installing it through the plugin marketplace.

How the Rules-Based Capture Workflow Operates​

With the syntax skills in place, Jonker instructed Claude Code to generate a short Markdown rules file inside the vault to govern its behavior:

1. Any prompt prefixed with note: is automatically appended to that day's daily note.
2. From the daily note, the entry is filed and linked appropriately across the vault.
3. The agent is explicitly forbidden from deleting or moving existing files.

Before drafting those rules, Claude Code inspected the existing vault folders and matched the daily note format already in use rather than inventing a mismatched template. Once configured, capturing a thought required just a single line. Feeding the agent a half-formed idea resulted in a properly formatted daily note entry filed in seconds, complete with relevant links to older notes. When asked to connect related material, Claude Code inserted cross-links with brief explanations for why the notes belonged together and flagged outdated links pointing to notes that no longer existed.

There were two notable caveats in the XDA Developers account:

• Unsolicited Verbosity: The agent tended to write more than requested, turning a one-sentence note into an expanded explanation and suggestion the author never asked for. Adding an explicit brevity rule in the .md configuration file is necessary if you want strict verbatim capture.
• Prompt Detachment: Relying primarily on terminal prompts—and taking extra steps to bring up an editor artifact for formatting—left the author feeling somewhat disconnected from the notes themselves compared to living inside a traditional editor.

Windows Setup and Security Realities for Claude Code​

For Windows users considering this route, official Anthropic documentation adds crucial context that separates "working in a local folder" from running offline. According to Anthropic's Getting Started documentation for Claude Code, the tool requires at least 4 GB of RAM, an x64 or ARM64 processor, a Paid/Pro/Max/Team/Enterprise/Console account (or third-party API provider like Microsoft Foundry, Amazon Bedrock, or Google Cloud), and an active internet connection. On Windows, you can install it natively via PowerShell, CMD, or WinGet (winget install Anthropic.ClaudeCode), run it inside WSL, or use the desktop app. Native Windows installations can run shell commands through PowerShell or use Git Bash if Git for Windows is installed.

More importantly, letting an AI agent loose inside your personal documentation requires a clear understanding of access boundaries. While Jonker added a Markdown rule telling Claude Code not to delete or move files, a prompt rule is a behavioral instruction to the model, not an operating-system lock. According to Anthropic's engineering documentation on Claude Code sandboxing, Claude Code uses a permission-based model that is read-only by default and asks for approval before modifying files or running commands. Because repeated prompts can cause "approval fatigue," Anthropic introduced /sandbox features built on OS-level primitives to enforce both filesystem isolation (restricting access to specific directories) and network isolation (restricting connections to approved servers) to defend against prompt injection. If you use an agent on your notes, keep it scoped strictly to your vault directory rather than launching it from your Windows user profile root.

Section Summary: Claude Code paired with Obsidian skills excelled at the tedious administrative side of note-taking—matching templates, filing daily notes, and building backlinks—though it requires an internet connection, careful prompt rules to curb verbosity, and sensible directory permissions.

LM Studio and a Local LLM: Privacy Meets the Context Wall​

On paper, replacing a cloud agent with a local model sounds like the ultimate note-taking dream: total data privacy, zero subscription fees, and an AI reasoning layer that never sends your personal thoughts off your machine. To test this, Jonker used LM Studio connected to a filesystem MCP server, which grants a local model permission to read and edit files inside user-approved directories.

The hardware and software stack used in the XDA Developers test reflects a realistic mid-range enthusiast PC:

• GPU: NVIDIA GeForce RTX 3070 with 8 GB of VRAM
• Primary Model: Qwen 3.5 9B quantized at Q4_K_M
• Secondary Model: A 4B variant used for quick note and document tasks
• Context Window: 30,000 tokens configured for the test session

Where the Local Filesystem Workflow Struggled​

Unlike the Claude Code setup, Jonker noted that this LM Studio workflow did not have a persistent vault rules file to lean on alongside the system prompt, meaning specific formatting and filing instructions had to be carried inside the user prompts themselves.

While the filesystem MCP server worked well in smaller directories, pointing it at a full-sized note vault exposed immediate friction:

• File-Ending Hallucinations: When asked to append a line under a new heading at the end of a note, the local model initially guessed how the file ended and got it wrong. It had to re-read the file to fix its mistake—and then repeated the exact same error later when trying to link two related files.
• Shallow Search: When asked to find notes about "onboarding," the setup only matched filenames rather than searching inside the body contents of the notes.
• Context Exhaustion: A single small demonstration consumed more than 20,000 tokens of the available 30,000-token context window, running out of breathing room long before a normal workday would end.

It is important to frame these results accurately. The 20,000-of-30,000 token consumption and file-editing hiccups come from one user's informal test on an 8 GB RTX 3070 running a 9B Q4_K_M model. They do not prove that local models are universally incapable of managing large note collections, nor do they isolate whether the bottleneck was vault size, how the filesystem MCP server chunks directory listings, prompt structure, or model parameter count. What they do illustrate is a very practical PC hardware reality: when a tool-using model has to inspect directory trees and read multiple Markdown files back and forth to verify edits, token usage climbs rapidly, and an 8 GB VRAM budget puts a hard ceiling on how much context and model weight you can keep resident at once.

Furthermore, running a model locally does not automatically eliminate file-access risk. According to LM Studio's official server settings documentation, enabling API clients to call MCP servers defined in mcp.json can pose a security risk if those servers have access to your filesystem or private data, which is why LM Studio requires authentication to be enabled for that setting. Always verify the exact folder paths approved for any filesystem MCP server.

Section Summary: Running Qwen 3.5 9B in LM Studio on an 8 GB RTX 3070 kept every note strictly local, but lacked persistent vault rules, struggled with content search and multi-file edits, and burned through over two-thirds of its 30k context window in a single demonstration.

Visual Studio Code (Without AI): The Unbeaten Reader and Search Engine​

For the third test, Jonker stripped away AI entirely and used Microsoft Visual Studio Code as a pure, raw text editor pointed at the note folder. Because VS Code treats a directory of Markdown notes the exact same way it treats a software repository, it requires zero configuration to start browsing.

Where VS Code dominated both AI setups was retrieval, reading, and change tracking:

• Instant File Navigation: Pressing Ctrl+P pulls up Quick Open, letting you jump to any note using any fragment of its filename.
• Vault-Wide Keyword Search: Searching across the workspace immediately lists every note containing a specific keyword inside its body text—solving the exact content-search failure that tripped up the local LLM test.
• Rendered Markdown Preview: Rather than staring at raw syntax, VS Code provides built-in rendered previews. As documented in Microsoft's Visual Studio Code documentation, users can also work with side-by-side editing and built-in Source Control views (Ctrl+Shift+G).
• Git Source Control Diffs: Because Git integration ships out of the box in VS Code, changing a single letter or number in a note highlights the exact modification in the gutter and diff viewer.

Where a stock, unextended VS Code setup fell short was capture and linking. Without extensions or AI helpers, there is no one-line daily note capture; jotting down a new thought means manually creating a file, naming it, and sorting it into a folder. Similarly, Obsidian-style [[wikilinks]] sit there as inert plain text in a default install. While the Visual Studio Marketplace offers extensions that add daily notes and wikilink navigation, out of the box it remains a manual editor.

Section Summary: Stock VS Code proved to be the best environment for actually reading notes, running full-text searches, and tracking edits via Git, even though manual file creation and plain-text wikilinks make raw capture slower than an automated agent.

Head-to-Head Comparison: How the Three Workflows Stack Up​

To put the XDA Developers test results and official platform requirements into perspective for Windows power users, here is how the three approaches compare across core note-taking tasks:

Practical Recommendations: Why You Don't Have to Pick Just One​

The overarching lesson from Jonker's experiment is that trying to force a single tool to handle capture, administration, and deep reading often means compromising on two of the three. Because all three tools operate on the exact same folder of standard .md files on your Windows drive, they are not mutually exclusive.

If you want to build a practical, low-friction Markdown workflow on Windows without losing your weekend to Notion templates, consider combining their strengths:

1. Use VS Code (or Obsidian) as Your Reading Room: Keep VS Code pointed at your vault with Git initialized. When you need to search for an old keyword, read rendered Markdown side by side, or review a diff to see what an AI agent changed in your files, nothing beats a fast local editor and Ctrl+P.
2. Use an Agent with Scoped Rules for Vault Hygiene: If you already pay for Claude Code and don't mind cloud processing for non-sensitive notes, equip your vault with kepano/obsidian-skills and a strict Markdown rules file. Tell the agent explicitly to keep entries concise, forbid file deletions, and let Git in VS Code act as your safety net so you can inspect or revert any overly chatty edits.
3. Keep Local MCP Workflows Scoped to Smaller Scratchpads: If you are running an 8 GB VRAM GPU like the RTX 3070, don't ask a 9B local model over a filesystem MCP server to swallow your entire multi-year archive at once. Instead, point the approved MCP folder at a smaller "Inbox" or weekly scratchpad directory where a 30k context window won't get swamped by directory metadata.

Have you tried turning a code editor or terminal agent loose on your Markdown vault, or do you prefer keeping AI out of your personal notes entirely? Share your setup and hardware specs in the WindowsForum community threads!