Source confidence: high

n8n-mcp + obsidian-skills — Two High-Leverage Claude Code Extensions

In short: Two of the most useful community-built extensions to Claude Code as of April 2026.

Key fact Detail
What it covers agents, automation, design, open source
Tools Claude, Claude Code, czlonkowski/n8n-mcp, glittercowboy/get-shit-done, hesreallyhim/awesome-claude-code
Posts covered 1 post (1 S-tier) · top: 7 must-install Claude Code repos — Obsidian…
Creators @chase.h.ai
Sources dated Feb 2026
Prompt system Run-it-yourself prompts
Last verified 2026-10-22

Two of the most useful community-built extensions to Claude Code as of April 2026. Both are in the same category — "expose a large, structured external system to Claude so it can reason about it natively" — but they attack very different domains: n8n-mcp (czlonkowski) unlocks workflow automation, and obsidian-skills (kepano) unlocks personal knowledge management. Covered in one guide because they're architectural siblings and often end up installed together on the same workbench.

Part 1: n8n-mcp — 1,396 n8n nodes exposed to Claude

Author: Romuald Czlonkowski (@czlonkowski) Repo: https://github.com/czlonkowski/n8n-mcp License: MIT Stars: ~17.8k (as of April 2026) — one of the most successful community MCP servers.

What it is

An MCP (Model Context Protocol) server that loads every n8n node's schema, documentation, and operation metadata into a searchable database and exposes it to Claude as tools. With it installed, Claude can natively design, validate, and (optionally) deploy n8n workflows without hallucinating node names, property shapes, or connection rules.

n8n is a workflow automation platform (think Zapier, but self-hostable and massively more powerful). It has ~1,400 nodes covering every major SaaS, database, LLM, file format, and protocol. The problem: that's too much surface area for an LLM to know from training alone — Claude will cheerfully invent nodes that don't exist, miss required fields, and wire up connections that won't run. n8n-mcp fixes that by making node metadata a first-class tool Claude can query.

How it works under the hood

Key mechanics

Installation (5 options, ranked by likely preference):

  1. NPX (quickest local) — no install, just point Claude at the binary:
    npx n8n-mcp
  2. Docker — pre-built image:
    docker pull ghcr.io/czlonkowski/n8n-mcp:latest   # ~280MB
  3. Hosted free tier at dashboard.n8n-mcp.com — 100 tool calls/day, API key signup only. Zero install.
  4. Railway one-click — if you want a persistent cloud MCP.
  5. Local dev clone — for hacking on it. Clone, npm install, npm run build, point Claude at dist/index.js.

Claude Code configuration (documentation-only, safest default):

Add to ~/.config/Claude/claude_desktop_config.json (Linux) or ~/.claude/settings.json for Claude Code:

{
  "mcpServers": {
    "n8n-mcp": {
      "command": "npx",
      "args": ["n8n-mcp"],
      "env": {
        "MCP_MODE": "stdio",
        "LOG_LEVEL": "error",
        "DISABLE_CONSOLE_OUTPUT": "true"
      }
    }
  }
}

The MCP_MODE: "stdio" env var is required — without it, the server writes log noise to stdout and Claude Code fails to parse the JSON-RPC stream. This is gotcha #1.

Full mode (Claude can deploy workflows directly):

{
  "mcpServers": {
    "n8n-mcp": {
      "command": "npx",
      "args": ["n8n-mcp"],
      "env": {
        "MCP_MODE": "stdio",
        "LOG_LEVEL": "error",
        "DISABLE_CONSOLE_OUTPUT": "true",
        "N8N_API_URL": "http://localhost:5678",
        "N8N_API_KEY": "your-n8n-api-key-here",
        "WEBHOOK_SECURITY_MODE": "moderate"
      }
    }
  }
}

For Docker, swap the n8n URL to http://host.docker.internal:5678.

Privacy: Telemetry is on by default. Disable with N8N_MCP_TELEMETRY_DISABLED=true.

Quick start

# 1. Install the MCP in Claude Code config (see above)
# 2. Restart Claude Code so it picks up the new MCP server
# 3. In any conversation, just ask:

> Build me an n8n workflow that watches a Gmail inbox for invoices,
  extracts the PDF attachment, runs it through the OpenAI node to pull
  out vendor/amount/date, appends to a Google Sheet, and posts a
  summary to Slack.

# Claude will:
#  - query n8n-mcp for the Gmail, PDF Extract, OpenAI, Sheets, Slack nodes
#  - read their actual schemas (not hallucinate)
#  - validate the workflow JSON against the MCP's validator
#  - return a complete workflow.json you can import into n8n
#  - (full mode) deploy it directly to your n8n instance

Gotchas

  1. Never point full-mode MCP at your production n8n. The docs are emphatic: always work on a dev instance. The MCP has no undo and Claude can edit any workflow it can see.
  2. MCP_MODE: "stdio" is mandatory for Claude Code. Omit it and you get opaque JSON parsing errors.
  3. Memory footprint: better-sqlite3 uses ~100-120MB; sql.js fallback ~150-200MB. Fine on a dev machine, worth knowing on a resource-constrained server.
  4. Webhook security: Default "strict" blocks localhost webhooks. For local dev, set WEBHOOK_SECURITY_MODE=moderate.
  5. Coverage isn't 100%. Operation coverage is 63.6% — rarer nodes may have incomplete action metadata. Claude will tell you when it's extrapolating vs. reading from the DB.

What we could build with it

Part 2: obsidian-skills — Kepano's Obsidian toolkit for Claude

Author: Stephan Ango (@kepano) — CEO of Obsidian, well-known in the PKM/note-taking community. Repo: https://github.com/kepano/obsidian-skills License: Check repo Status: Active, following the emerging "Agent Skills" specification.

What it is

A collection of five agent skills built to the open Agent Skills specification, designed to let any skills-compatible agent (Claude Code, Codex CLI, OpenCode, etc.) work directly with Obsidian vaults. The skills handle Obsidian's specific flavors of markdown, its Bases feature (database views over notes), JSON Canvas files, and vault CLI operations.

The point: Obsidian is the dominant markdown PKM system. Claude Code is the dominant coding agent. Until obsidian-skills, there was no clean way for Claude to read, write, or manipulate an Obsidian vault while respecting Obsidian's conventions (wikilinks, properties, callouts, templates, Bases formulas). Kepano — literally the CEO of Obsidian — shipped the reference implementation.

The five skills

  1. obsidian-markdown — Create and edit Obsidian Flavored Markdown. Handles:
    • Wikilinks ([[Note Name]], [[Note Name|alias]])
    • Embeds (![[Note Name]], ![[image.png]])
    • Callouts (> [!note], > [!warning])
    • Properties (YAML frontmatter with Obsidian-specific types: tags, aliases, date types)
    • Block references ([[Note Name#^block-id]])
  2. obsidian-bases — Create and manipulate Obsidian Bases (the database-view-over-notes feature introduced in 2025). Handles views, filters, formulas, summaries. This is the only tool outside Obsidian itself that understands Bases syntax.
  3. json-canvas — Work with JSON Canvas files (the open spec Obsidian uses for its infinite canvas feature). Create nodes, edges, groups, connections — perfect for agent-generated mind maps or visual plans.
  4. obsidian-cli — Shell-level interaction with Obsidian vaults. Useful for plugin developers, theme developers, and bulk vault operations.
  5. defuddle — Extract clean markdown from web pages using the Defuddle tool (kepano's readability/clipper engine). This is the "web → vault" ingestion step.

Installation

Five install methods depending on your agent:

# Claude Code — per-vault install (most common)
cd ~/vaults/my-vault
mkdir -p .claude
cd .claude
# Copy the skill directories from the repo into here
# (or git clone the repo and symlink the skill subdirs)

# Codex CLI
cp -r obsidian-skills/* ~/.codex/skills/

# OpenCode
git clone https://github.com/kepano/obsidian-skills ~/.opencode/skills/

Per the repo's instructions: "Add the contents of this repo to a /.claude folder in the root of your Obsidian vault." That makes them available whenever Claude Code is launched inside that vault.

Key mechanics

Quick start

# 1. Clone or copy obsidian-skills into your vault's .claude folder
cd ~/Documents/ObsidianVault
git clone https://github.com/kepano/obsidian-skills .claude/obsidian-skills

# 2. Launch Claude Code from inside the vault
cd ~/Documents/ObsidianVault
claude

# 3. Ask it to do Obsidian-native things:
> Read all notes tagged #project/active, summarize each, and create a
  new note "Active Projects Dashboard" with links and 2-line summaries.

> Clip this URL into a new note with proper frontmatter and tags:
  https://www.example.com/article

> Build a JSON Canvas visualizing how my notes in the "Claude Code"
  folder link to each other.

> Create an Obsidian Base that shows all notes with status="in-progress"
  sorted by last modified, with formulas for days-since-touched.

Gotchas

  1. Vault path assumptions. The skills expect to be run from inside the vault root. Running from a subfolder can confuse relative path resolution.
  2. Obsidian sync conflicts. If Obsidian Sync / iCloud / Syncthing is running on the vault, Claude's writes can race with the sync layer. Close/pause sync during heavy edits.
  3. Bases is new. The obsidian-bases skill tracks Obsidian's Bases feature, which is still evolving. If your Obsidian version predates Bases, that skill is a no-op.
  4. Wikilink targets aren't validated. Claude will happily create [[Broken Link]] pointing to a non-existent note. Use Obsidian's graph view or an "unresolved links" plugin to catch these.
  5. Don't mix with MCP servers that also touch the vault. If you have an Obsidian MCP AND obsidian-skills, decide which one is authoritative — otherwise Claude will sometimes use one and sometimes the other with inconsistent conventions.

What we could build with it

Why these two together

n8n-mcp and obsidian-skills are the same idea at different altitudes:

n8n-mcp obsidian-skills
Domain Workflow automation Personal knowledge management
Shape MCP server (tool endpoints) Agent skills (markdown instructions)
Knowledge substrate SQLite DB of node schemas Obsidian syntax + file conventions
Coverage 1,396 nodes 5 skill domains
Typical user Developer automating systems Knowledge worker managing notes
Claude gains Ability to design valid workflows Ability to manipulate vaults natively

Together they cover "automate the world" + "remember the world." A Claude Code workbench with both installed can:

  1. Use obsidian-skills to turn a brainstorm into a structured set of notes + canvas.
  2. Use n8n-mcp to translate any of those notes into a live automation.
  3. Use obsidian-skills again to write the results back into the vault as a closed loop.

This is the PKM-meets-automation pattern and it's genuinely new in early 2026.

Install recommendation for you

You may already have 5 MCP servers (Figma, Playwright, Context7, GitHub, Ruflo) and 13 custom skills. Adding these:

Repos

Clone both repos:

mkdir -p repos && cd repos
git clone https://github.com/czlonkowski/n8n-mcp.git
git clone https://github.com/kepano/obsidian-skills.git

Both are worth keeping — n8n-mcp for the pre-built SQLite schema database (useful reference even without running the server), obsidian-skills for the SKILL.md files (useful templates for your own skill authoring, plus ready to drop into any vault).

Sources

Prompt system — run this yourself

Everything below is pasteable into Claude Code, Claude, or any agent. Use the one-shot when you want the whole result in one run; use the step prompts when you want to steer. Every step carries its own audit, and the gap audit at the end makes the agent find and fill what it missed.

Mission. Install czlonkowski's n8n-mcp and kepano's obsidian-skills into Claude Code safely and prove each one changes outcomes: n8n-mcp should turn natural-language requests into n8n workflows that import and execute on a disposable dev instance, and obsidian-skills should make Claude produce Obsidian-native notes, Bases, and JSON Canvas files that open correctly in Obsidian. Done means a measured with-versus-without comparison for each tool, a dev-only n8n with a scoped API key that never touches production, a backed-up test vault, and a gap report on the guide's coverage and install claims.

1 · Deeper, not bigger

Before running anything, make the task deeper rather than larger. Ask: what would a top professional do here that I am not asking for; what is the rawest material; which methods and tools; what, other than the model or me, proves it right. Then ask for exactly that.

Rewritten prompt — ask for exactly that:

Act as an automation engineer and Obsidian power user evaluating n8n-mcp (github.com/czlonkowski/n8n-mcp) and obsidian-skills (github.com/kepano/obsidian-skills) in Claude Code. First read both repos' READMEs and the n8n-mcp tools documentation, and find out from Claude Code's own docs where MCP servers are configured on my version (the guide says ~/.claude/settings.json; verify). Start a disposable n8n in Docker on localhost:5678, create an API key there, and export it as an environment variable without printing it. Add n8n-mcp with MCP_MODE=stdio, LOG_LEVEL=error, DISABLE_CONSOLE_OUTPUT=true, telemetry disabled, and WEBHOOK_SECURITY_MODE=moderate, pointed only at that dev instance. Write 10 workflow requests from my real needs, generate each with and without the MCP, import each into n8n, run each on fixture data, and record invalid nodes, validation errors, and execution status. Then copy my vault to a git-tracked test copy, install obsidian-skills into its .claude folder, and run 8 tasks (dashboard note, web clip, Base with formulas, JSON Canvas of links, properties cleanup) with and without the skills. Lint results for unresolved links and bad frontmatter and open them in Obsidian. Return both comparison tables, the configs (no secrets), and a list of guide claims that were wrong.

2 · One-shot prompt

ROLE AND STANCE
You are an automation engineer and knowledge-management practitioner installing two community extensions into Claude Code and proving, with measurements, that each one improves results. You never give an agent write access to production systems or an unbacked-up vault, and you never print secrets.

CONTEXT
- n8n-mcp (czlonkowski, MIT, github.com/czlonkowski/n8n-mcp): MCP server with a prebuilt SQLite database of n8n nodes and templates. Guide figures to TEST: 1,396 nodes (812 core, 584 community), 99 percent property coverage, 63.6 percent operation coverage, 87 percent documentation coverage, 2,709 templates. Modes: documentation-only (no n8n needed) and full mode with N8N_API_URL and N8N_API_KEY. Install via `npx n8n-mcp`, Docker ghcr.io/czlonkowski/n8n-mcp, hosted tier (100 calls/day), Railway, or local build. Gotchas: MCP_MODE=stdio is mandatory or stdout noise breaks JSON-RPC; never point full mode at production; WEBHOOK_SECURITY_MODE strict blocks localhost; telemetry on by default (N8N_MCP_TELEMETRY_DISABLED=true); memory 100-200 MB.
- obsidian-skills (kepano, github.com/kepano/obsidian-skills): Agent Skills for obsidian-markdown (wikilinks, embeds, callouts, properties, block refs), obsidian-bases (views, filters, formulas, summaries), json-canvas (nodes, edges, groups), obsidian-cli, and defuddle (web to Markdown). Installed per vault under the vault's .claude folder; Claude Code launched from the vault root. Gotchas: sync conflicts with Obsidian Sync, iCloud, or Syncthing; Bases requires a recent Obsidian; wikilink targets not validated; conflicts with an Obsidian MCP if both are installed.
- Claims to TEST: the guide's Claude Code config path (~/.claude/settings.json) for MCP servers; that obsidian-bases is the only tool outside Obsidian that understands Bases syntax; that the MCP tells you when it extrapolates.

HARD CONSTRAINTS
- n8n full mode only against a disposable Docker instance on localhost with its own volume. Never a production URL.
- N8N_API_KEY lives in the environment only; never write it into a committed file, never echo it, never paste it into a prompt.
- Work on a copy of the vault under git; pause any sync on that copy. Never write to the real vault during evaluation.
- Pin versions: n8n image tag, n8n-mcp version, obsidian-skills commit, Obsidian app version.

ORDERED DELIVERABLES
1. ground-truth.md: versions; where this Claude Code version reads MCP config; n8n-mcp's actual tool list from its tools_documentation; the node/template counts the server reports versus the guide; the obsidian-skills SKILL.md list and what each teaches; Obsidian version and whether Bases is available.
2. n8n-dev/: docker command or compose file, a fixtures folder (sample webhook payloads, a CSV), and a note on how the API key was created and where it is stored (name only).
3. MCP registration (command used, config with secrets referenced by env var only) and a test call to search nodes.
4. eval/n8n.csv: 10 workflow requests from the user's real needs, each generated without and with n8n-mcp; per run: unknown node types, invalid parameters, MCP validation errors, import ok, execution status on fixtures, minutes of manual fixing.
5. vault-test/: git-initialised copy of the vault with obsidian-skills under .claude/.
6. eval/obsidian.csv: 8 tasks (active-projects dashboard with wikilinks, clip a URL with defuddle and frontmatter, Base of in-progress notes sorted by modified with a days-since-touched formula, JSON Canvas of a folder's link graph, callout-formatted meeting note, properties cleanup across 20 notes, block-reference summary, embed-based index) each without and with skills; per run: opens in Obsidian, unresolved links added, frontmatter parse errors, canvas schema errors, files changed outside scope.
7. lint/: scripts for wikilink resolution, YAML frontmatter parsing, and JSON Canvas schema validation.

BUILT-IN GAP ANALYSIS
Before finishing, write gaps.md: guide claims with verdicts; workflow requests that failed even with the MCP and why (missing node coverage, credentials, community nodes); Obsidian features the skills did not handle; any time Claude mixed conventions or wrote outside the target folder; anything you could not test (hosted tier, Railway, Codex or OpenCode installs). Fix the fixable now (for example add a CLAUDE.md note in the vault copy forbidding writes outside a folder) and re-run the affected tasks.

SELF-QUESTIONS BEFORE FINISHING
- Is the n8n instance truly disposable, and could any config path reach a production n8n?
- Did the API key ever appear in a log, transcript, or committed file?
- Did I verify where Claude Code reads MCP servers, or copy the guide's path?
- Do the with-MCP workflows actually execute on fixtures, or only import?
- Does each generated .base and .canvas open in the installed Obsidian version?
- Did Claude create wikilinks to notes that do not exist?
- Did any task change files outside its target folder in the vault copy?
- Is another Obsidian MCP or plugin also acting on the vault?

STOP CONDITIONS
Stop when both comparison tables are filled and gaps.md is written. Stop and ask before connecting to any non-local n8n, before installing skills into the real vault, or if a workflow needs real third-party credentials.

RETURN FORMAT
One message: versions; config snippets with secrets as env var references; n8n comparison summary (without vs with: valid workflows, successful executions, mean fix minutes); Obsidian comparison summary (without vs with: files that open, unresolved links, frontmatter errors); claims verdicts; gaps.md contents; instructions to promote to the real vault if the user chooses.

3 · Step-by-step prompts

Step 1 — Ground truth: repos, config paths, versions

Goal: Pin what both extensions really provide and where Claude Code loads them.

Clone github.com/czlonkowski/n8n-mcp and github.com/kepano/obsidian-skills into repos/ and record commit hashes. From n8n-mcp's README and release notes, record the stated node, template, and coverage figures and the full list of exposed tools and environment variables. From Claude Code's documentation for your installed version (`claude --version`), find exactly where MCP servers are configured (`claude mcp add` scopes, .mcp.json, ~/.claude.json) and compare with the guide's claim of ~/.claude/settings.json; record the verdict. Read every SKILL.md in obsidian-skills and summarise what each teaches and any reference files it loads. Check the installed Obsidian version and whether Bases and the current JSON Canvas spec version are supported; read jsoncanvas.org's spec and note required node and edge fields. Write ground-truth.md with: versions, the config-path verdict, the MCP tool list, the guide-versus-repo figure table, and a one-line purpose per skill.

Expect: ground-truth.md with commit hashes, a config-path verdict citing the docs, a tool list, a figures table, and five skill summaries.

Audit before moving on: Any figure in the table without a source line in the repo is marked unverified. If the guide's MCP config path is wrong for this version, every later step must use the documented path; note that at the top of the file.

Step 2 — Stand up a disposable n8n and register n8n-mcp

Goal: Give the MCP a safe target and confirm it works in Claude Code.

Start n8n with `docker run -d --name n8n-dev -p 127.0.0.1:5678:5678 -v n8n_dev_data:/home/node/.n8n docker.n8n.io/n8nio/n8n:<pinned-tag>`. Create the owner account in the UI, then create an API key under settings. Store it in your shell environment or a gitignored env file as N8N_API_KEY; do not echo it. Verify with `curl -s -o /dev/null -w '%{http_code}' -H "X-N8N-API-KEY: $N8N_API_KEY" http://localhost:5678/api/v1/workflows` expecting 200. Register n8n-mcp using the documented method from step 1, for example `claude mcp add n8n-mcp -e MCP_MODE=stdio -e LOG_LEVEL=error -e DISABLE_CONSOLE_OUTPUT=true -e N8N_MCP_TELEMETRY_DISABLED=true -e WEBHOOK_SECURITY_MODE=moderate -e N8N_API_URL=http://localhost:5678 -e N8N_API_KEY=$N8N_API_KEY -- npx n8n-mcp@<version>`, and check where that wrote the key and whether that file is committed anywhere. In Claude Code, call the MCP's documentation tool, then search for the Gmail, Google Sheets, Slack, HTTP Request, and Code nodes, and record the reported node count. Create n8n-dev/fixtures with a sample webhook JSON payload and a 20-row CSV.

Expect: A running n8n-dev container, a 200 from the API check, the MCP listed by claude mcp list, search results for five nodes, and fixtures.

Audit before moving on: Grep the repo and home config files you touched for the key's prefix and confirm it appears only in the intended env store with restrictive permissions. If the MCP fails to connect, test once without MCP_MODE to confirm the guide's 'stdout noise' gotcha, then restore it.

Step 3 — Evaluate workflow generation with and without the MCP

Goal: Measure whether n8n-mcp reduces invalid workflows and failed executions.

Write 10 workflow requests from the user's real automation needs, mixing simple (webhook to Slack message), medium (CSV in, transform with Code node, append to sheet), and complex (the guide's Gmail invoice example: watch inbox, extract PDF, OpenAI extract vendor/amount/date, append to Sheets, post to Slack). For each, run two fresh Claude Code sessions: one with n8n-mcp disabled, asked to output importable n8n workflow JSON; one with the MCP enabled, asked to search nodes, read schemas, validate with the MCP's validator, and create the workflow on the dev instance. Import the no-MCP JSON via the API (POST /api/v1/workflows). For both, record unknown node types, invalid parameters reported on import or in the editor, validation errors. Execute each using test data: trigger webhooks with the fixture payload, replace nodes needing real credentials with a Set or HTTP Request to a local echo endpoint and note that substitution. Fetch execution status from /api/v1/executions. Log minutes of manual fixing needed to make each run. Save eval/n8n.csv.

Expect: eval/n8n.csv with 20 rows and a summary: valid imports, successful executions, and mean fix minutes per condition.

Audit before moving on: Confirm both conditions got identical request text and fresh sessions. Any workflow counted as success must have an execution record with status success in n8n. Credential substitutions must be identical across conditions.

Step 4 — Prepare a safe vault copy and install obsidian-skills

Goal: Give the skills a realistic vault with an undo button.

Copy the real vault to ~/vault-test with `rsync -a --exclude .obsidian/workspace* <vault>/ ~/vault-test/`, then `git init && git add -A && git commit -m baseline` inside the copy. Make sure no sync service (Obsidian Sync, iCloud, Syncthing) watches ~/vault-test. Install the skills per the repo's instructions: `git clone https://github.com/kepano/obsidian-skills ~/vault-test/.claude/obsidian-skills` or copy each skill directory into ~/vault-test/.claude/skills/ according to the layout Claude Code expects for project skills on this version (verify from docs). Launch `claude` from the vault root and ask it to list available skills to confirm all five load. Check for any Obsidian MCP server also configured and disable it for this test. Write lint/ scripts: wikilinks.py (find [[targets]] and embeds that do not resolve to a file or alias, counting new ones versus the baseline), frontmatter.py (YAML parse, property types for tags, aliases, dates), canvas.py (validate .canvas against the JSON Canvas 1.0 required fields and ids). Run all three on the baseline and save counts.

Expect: A git-tracked vault copy, five skills listed in Claude Code, three lint scripts, and baseline lint counts.

Audit before moving on: Run git status in the copy after launching Claude; it must be clean before tasks start. If the skills do not load from the guide's path, find the correct path and record it as a guide correction.

Step 5 — Evaluate Obsidian tasks with and without skills

Goal: Measure whether the skills make output Obsidian-native and correct.

Run 8 tasks, each twice from a clean git state (`git stash -u` or `git checkout . && git clean -fd` between runs): once with the skills folder temporarily moved out, once with it in place. Tasks: (1) read notes tagged #project/active and create 'Active Projects Dashboard' with wikilinks and 2-line summaries; (2) clip a given URL into a note with defuddle-style clean Markdown, frontmatter source, created, tags; (3) create a .base showing notes with status in-progress sorted by last modified with a days-since-touched formula; (4) build a .canvas of how notes in one folder link to each other, grouped by subfolder; (5) write a meeting note with callouts for decisions and risks; (6) normalise properties across 20 notes (tags as list, dates ISO); (7) summarise a long note using block references; (8) build an index note with embeds of three notes. After each run: run the lint scripts, record new unresolved links, frontmatter errors, canvas errors, and files changed outside the task's target (from git diff --name-only); open the created files in Obsidian and record whether they render as intended. Save eval/obsidian.csv.

Expect: eval/obsidian.csv with 16 rows and a with-versus-without summary per metric.

Audit before moving on: Confirm git was reset between every run by checking that the 'files changed' list contains only that run's outputs. Any task where Obsidian shows an error opening a .base or .canvas is a fail regardless of lint results.

Step 6 — Validate against oracles and write the gap report

Goal: Confirm results with n8n and Obsidian themselves and list remaining gaps.

For n8n: list workflows and executions from the API and confirm every success in eval/n8n.csv has an execution with status success; delete test workflows afterwards or tag them. For Obsidian: open every with-skills output again in Obsidian and confirm it renders; re-run the lint scripts on the final state. Compute final tables. Write gaps.md with: guide claims and verdicts (node and coverage figures, config path, MCP_MODE gotcha, 'only tool that understands Bases', extrapolation warnings, install layout); requests that failed in both conditions and why; Obsidian features the skills missed; any write outside scope; untested install paths (hosted tier, Railway, Codex, OpenCode). Rank by impact and fix the top fixable item now: add a vault-test/CLAUDE.md limiting writes to named folders and requiring lint after edits, then re-run the worst task. Write promotion.md with backup and sync-pause commands for the real vault and a documentation-only n8n-mcp default, but do not execute it. Finally, stop the n8n-dev container (keep the volume unless the user wants it removed) and confirm `claude mcp list` still points only at localhost.

Expect: Final comparison tables, gaps.md with every claim resolved, and n8n-dev stopped.

Audit before moving on: Every claimed success must map to an n8n execution id or an Obsidian render check. If the with-tool advantage is within noise for either extension, say so and recommend accordingly.

4 · Gap analysis and audit

Run this after the build. It makes the agent enumerate its own claims, mark what is verified, rank the gaps and fix the top ones.

You are auditing an n8n-mcp and obsidian-skills evaluation built by someone else: n8n-dev/, MCP registration, eval/n8n.csv, vault-test/, lint/, eval/obsidian.csv, promotion.md, gaps.md. Do not trust the summaries. (1) List every claim: safety (dev-only n8n, no key exposure, vault copy only), each eval verdict, and each guide-claim verdict. (2) Verify: grep every config file, shell history, and Claude transcript you can access for the API key prefix; confirm N8N_API_URL points to localhost; re-execute three 'successful' workflows and check execution ids; reset vault-test to a run's commit and re-open its .base and .canvas in Obsidian; re-run the lint scripts. Mark verified, unverified, or false. (3) Hunt silent failures: workflows that import but contain disabled or placeholder nodes; credential substitutions that make a run trivially pass; lint scripts that skip aliases or embeds; skills that did not actually load in the with-skills runs. (4) Check fairness: same prompts, fresh sessions, git reset between runs. (5) Rank gaps by impact (secret exposure, production risk, vault damage, wrong recommendation), fix the top three now, and report the remainder with a reproduction command each.

Questions the agent must ask itself before it says done:

5 · What proves it right

6 · Failure modes

7 · Agent direction (unattended runs)

Read both repos and Claude Code's MCP docs first; correct the config path before registering anything. Bring up n8n-dev and the vault copy before any generation so every write has a safe target. Use the MCP's documentation tool at the start of each n8n session because tool names change. Never print, log, or paste N8N_API_KEY; reference it by name only. Spawn subagents for the paired with/without runs so each gets a fresh context, and a separate grader for opening and checking Obsidian outputs. Stop and ask before any non-local n8n URL, any write to the real vault, or any workflow needing real third-party credentials. Do not execute promotion.md. Return in chat versions, safety confirmations, both comparison summaries, claim verdicts, and gaps; files: ground-truth.md, n8n-dev/, eval/n8n.csv, vault-test/ (with CLAUDE.md), lint/, eval/obsidian.csv, promotion.md, gaps.md.

Prompt system updated 2026-10-22 · all prompt systems · JSON