2 compare and choose Workspace Editors

A workspace editor serve the purpose of helping me interact with a vault or workspace - comprised a repository of nested folders and files that include markdown, csv, spreadsheets and images.

Candidates include :-

• VSCode is from Microsoft and its first foray into Open Source and for a  lightweight, cross-platform code editor that could run on Windows, macOS, and Linux, distinct from the heavier, Windows-centric Visual Studio IDE.

  Perhaps they took inspiration from Chrome and their own abandonment of Internet Explorer and adoption of Google’s offering to create Edge?

• Cursor uses VSCode open source and has a deeper integration with AI. Its free to a point but then does overlay a subscription model for greater AI use.
• Obsidian has origins from a productivity / note taking then really a programming pedigree. However its strength is that it works on plain markdown files meaning one can “share” a workspace with above.

Hybrid : Obsidian then Cursor - the winner

It does not have to be an either/or decision. In fact, using both tools on the same vault is a highly effective workflow, especially for “vibe coding” where you want AI to handle the heavy lifting while you focus on structure and review.

Since both editors work directly on the same nested folder of Markdown files, they are naturally compatible.

How to Use Them Together

1. The “Best of Both Worlds” Workflow

You can leverage the specific strengths of each tool without conflict:

• Use Obsidian for:
  • Visualization: Viewing the Graph, using Canvas, and managing plugins like Dataview or Excalidraw.
  • Manual Editing: Writing thoughts, organizing links, and managing your “second brain” interface.
  • Spreadsheets: Editing your Excel files directly using the Univer or Excel plugins (which Cursor cannot do).
• Use Cursor for:
  • Vibe Coding: Asking your Mammouth Code agent to “Refactor all my templates,” “Create 50 new daily notes,” or “Find broken links across the vault.”
  • Complex Refactoring: Using the Composer feature to edit 20 files at once based on a natural language prompt.
  • Terminal Agents: Running Mammouth Code directly in the integrated terminal to execute scripts or manage files autonomously.

2. Technical Compatibility

• File Safety: Both applications monitor the file system for changes. If you edit a file in Cursor, Obsidian will automatically detect the change and reload it (and vice versa). There is no risk of corruption as long as you aren’t typing in the exact same file in both windows at the exact same millisecond.
• No Sync Needed: Since they point to the same local folder, there is no need for synchronization plugins. They share the same “source of truth.”

3. Bridging the Gap: Bringing Cursor’s AI into Obsidian

If you prefer staying in Obsidian but want Cursor’s powerful AI agents:

• Obsidian-Cursor Plugin: A community plugin exists that connects Obsidian directly to the Cursor CLI. This allows you to run Cursor’s “Ask,” “Plan,” and “Agent” modes inside an Obsidian pane, using your vault as the workspace. This gives you Mammouth/Cursor-level agentic capabilities without leaving the Obsidian interface.
• Mammouth Code CLI: You can run mammouth in your system terminal while Obsidian is open. The agent will modify files in your vault, and Obsidian will instantly reflect those changes.

Recommended Setup for “Lapsed Coders”

Given your background, this hybrid approach is ideal:

1. Keep Obsidian as your primary interface for reading, writing, and viewing spreadsheets.
2. Open the same vault folder in Cursor when you need to perform bulk actions (e.g., “Rename this tag in 500 files” or “Generate a summary of this project”).
3. Let Mammouth Code do the coding: You don’t need to know how to write the script to fix your files; you just tell Mammouth in Cursor what you want done, review the proposed changes, and let it execute. Then switch back to Obsidian to see the result.

This setup gives you the safety and visualization of Obsidian with the agentic power of Cursor/Mammouth, without requiring you to choose one or master complex coding skills.

Obsidian vs Cursor for spreadsheets

Planning a vault to help me manage money, investments and general personal finance. This will involve spreadsheets so comparing the right frount end tool for this…

• Obsidian can natively edit Excel files (.xlsx) but only via community plugins.
• Cursor (and VS Code) cannot natively edit Excel files; it treats them as binary blobs unless you use AI to write code to manipulate them or install specific extensions that often only offer viewing, not full editing.

Here is the breakdown of how each meets your requirement:

1. Obsidian (Strong for Spreadsheets via Plugins)

Obsidian is primarily a Markdown editor, but its plugin ecosystem allows it to function as a spreadsheet editor.

• Editing Capability: With the Excel plugin (based on x-spreadsheet) or the newer Univer plugin, you can open, edit, and save .xlsx files directly within the Obsidian interface.
  • Univer Plugin: Offers advanced features like formulas, cell styling, conditional formatting, and multi-sheet support, closely mimicking Excel.
  • Excel Plugin: Provides a lighter grid interface for basic data entry and editing.
• Integration: You can embed live spreadsheet views directly into your Markdown notes, creating a unified dashboard of text and data.
• Mammouth Integration: You can use your Mammouth Code subscription via Obsidian’s AI plugins (like Smart Connections or Copilot) to analyze the data within these sheets or generate Markdown reports based on them.

2. Cursor (Weak for Direct Spreadsheet Editing)

Cursor is an AI-powered code editor (fork of VS Code). While excellent for code and Markdown, it is not designed for direct spreadsheet manipulation.

• Editing Capability: Cursor lacks a native grid interface for .xlsx files.
  • Workarounds: You can install extensions like Excel Viewer to read data, but editing usually requires converting the file to CSV (losing formatting/formulas) or asking the AI to write a Python/Node script to modify the file programmatically.
  • AI Approach: You would typically prompt Cursor: “Read this Excel file and update column B based on X,” and it would generate a script to execute the change, rather than you clicking cells to edit them manually.
• Mammouth Integration: Cursor allows you to configure custom AI models. You can point Cursor to use your Mammouth Code API endpoint (if Mammouth provides an OpenAI-compatible API) to power its chat and autocomplete features, leveraging Mammouth’s models for code generation and text analysis.

Recommendation

Requirement	Obsidian	Cursor
Navigate Markdown	Excellent (Native)	Excellent (Native)
Read Excel	Excellent (via Plugin)	Good (via Extension/CSV)
Edit Excel (Grid)	Yes (via Univer/Excel Plugin)	No (Requires coding/scripts)
AI Integration	Via Community Plugins	Native (Can connect Mammouth API)
Best Use Case	Knowledge Base + Data Entry	Coding + Automated Data Processing

Conclusion: If your workflow requires manually clicking cells, entering data, and using formulas in Excel files alongside your Markdown notes, Obsidian (with the Univer plugin) is the superior choice.

If your workflow involves programmatically transforming data (e.g., “clean this dataset” or “extract these rows”) and you prefer using AI to write the code to do it, then Cursor with your Mammouth subscription is the better fit. You cannot effectively do manual spreadsheet editing in Cursor.

Obsidian vs Cursor for no spreadsheets

If you have vaults that do not require spreadsheets, Cursor offers significant advantages over Obsidian specifically for coding, complex refactoring, and AI-driven workflows.

Here is why Cursor is superior for code-heavy Markdown vaults:

1. Native AI Architecture vs. Plugin Patchwork

• Cursor (AI-Native): AI is built into the editor’s core. It indexes your entire vault automatically, allowing you to ask questions like “Where did I define the API schema?” or “Refactor all my Python scripts in this folder” with immediate, context-aware answers. It uses your Mammouth Code subscription directly via the terminal or Cline extension for deep, agentic tasks.
• Obsidian (Plugin-Dependent): AI requires third-party plugins (e.g., Smart Connections, Copilot). These often suffer from fragmentation: one plugin handles chat, another handles embeddings, and none offer the seamless, low-latency “Tab-to-complete” or multi-file editing found in Cursor. Setting up Mammouth in Obsidian requires manual configuration of API keys in specific plugins, whereas Cursor integrates it as a first-class citizen.

2. Multi-File Refactoring & “Composer”

• Cursor: Its standout feature, Composer, allows you to edit multiple files simultaneously. You can instruct it to “Update the function signature in utils.md and propagate the change to all 10 markdown files that reference it,” and it will generate a unified diff for you to approve. This is critical for maintaining consistency in large code/documentation bases.
• Obsidian: Lacks native multi-file editing. Changing a reference across multiple notes usually requires manual find-and-replace or complex Dataview queries, which cannot edit files, only view them.

3. Terminal & Agent Integration (Mammouth Code)

• Cursor: Designed to run Mammouth Code directly in its integrated terminal. You can trigger autonomous agents to “Create a new documentation structure,” “Run linters on all scripts,” or “Generate a summary of changes” without leaving the window. The AI has direct access to execute commands and see the output.
• Obsidian: Has no native terminal. Running scripts or agents requires switching to an external terminal window, breaking the flow. While plugins exist to embed terminals, they are often clunky and lack the deep integration Cursor offers for AI agents.

4. Code Intelligence

• Cursor: Provides true IDE features: Go to Definition, Find References, and Rename Symbol work across your entire vault (even for code blocks inside Markdown). It understands the syntax tree of your code snippets.
• Obsidian: Treats code blocks as plain text. It cannot navigate between function definitions or validate syntax across files without heavy, often brittle, plugin configurations.

Summary: When to Choose Cursor

Choose Cursor for these vaults if:

• You treat your Markdown files as code/documentation hybrids (e.g., technical docs with embedded scripts).
• You need to refactor content across many files at once.
• You want to leverage Mammouth Code for autonomous tasks (file creation, running tests, linting).
• You prefer a “Vibe Coding” workflow where AI handles the heavy lifting of file management and editing.

Stick with Obsidian only if:

• Your workflow is purely writing/thinking with minimal code.
• You rely heavily on graph visualization or specific plugins like Dataview or Excalidraw which Cursor does not replicate.
• You strictly want a local-first, non-AI-native editor and are willing to configure plugins manually.