New: 97,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Debug Obsidian

by saberzero1 in saberzero1/quartz-syncer

Debug and investigate plugin issues in a running Obsidian instance — collect diagnostic data, inspect state, trace events, and identify root causes via the operability facade.

MITAuto-check passedDevelopment

Install Debug Obsidian

skills CLI
$ npx skills add saberzero1/quartz-syncer --skill debug-obsidian -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install saberzero1/quartz-syncer debug-obsidian --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/saberzero1/quartz-syncer.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.agents/skills/debug-obsidian .claude/skills/debug-obsidian && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
debug-obsidian
GitHub stars
139
Token cost
~1.9k tokens
SKILL.md length
599 words
Files
1
Skills in repo
4
Repo updated
First seen
Licence
MIT

At a glance

Debug and investigate plugin issues in a running Obsidian instance — collect diagnostic data, inspect state, trace events, and identify root causes via the operability facade.

  • Works in 7 steps: Collect failure bundle → Analyze the snapshot → Analyze events → …
  • Tasks that involve Root cause analysis
  • SKILL.md covers Purpose, Prerequisites, When to Activate and Workflow, plus 2 more sections
  • Calls npm

What it does

Debug Obsidian is an agent skill from saberzero1/quartz-syncer. Debug and investigate plugin issues in a running Obsidian instance — collect diagnostic data, inspect state, trace events, and identify root causes via the operability facade.

Its SKILL.md is about 1.9k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Development, covering Root cause analysis and Debugging. It works with Obsidian. The repository describes itself as: Manage and publish your notes to Quartz, the fast, batteries-included static-site generator. The licence is MIT.

When your agent uses it

  • Tasks that involve Root cause analysis
  • Tasks that involve Debugging

Example prompts

  • “/debug-obsidian”

Workflow steps

7 steps, taken from the step headings in SKILL.md.

  1. Collect failure bundle
  2. Analyze the snapshot
  3. Analyze events
  4. Check console errors
  5. Targeted investigation
  6. Wait for conditions
  7. Mobile-specific debugging

What it can do on your machine

Read from SKILL.md and the folder at commit 8f04c08. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • npm

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md. Its commands use npm, which can reach the network depending on how they are called.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Debug Obsidian loads about 1.9k tokens when it runs. Until then it costs about 48 tokens; SKILL.md has 599 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~48
When it runs · the whole SKILL.md, loaded when a task matches
~1.9k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from saberzero1/quartz-syncer at commit 8f04c08, republished under its MIT licence (© saberzero1). 599 words, ~1,949 tokens.

Download SKILL.mdSave it as .claude/skills/debug-obsidian/SKILL.md (or your agent's skills folder).
name
debug-obsidian
description
Debug and investigate plugin issues in a running Obsidian instance — collect diagnostic data, inspect state, trace events, and identify root causes via the operability facade.
triggers
debug, investigate, something broke, error, not working, broken, diagnose
argument-hint
[symptom-description]

Debug Obsidian Skill

Purpose

When the plugin isn't behaving correctly in Obsidian, systematically collect diagnostic data, inspect internal state, and trace events to identify the root cause. Uses the operability facade, console capture, and DOM inspection.

Prerequisites

  • Obsidian must be running.
  • Plugin should be built with npm run build:dev (enables facade via __DEV__ flag).
  • Console capture requires obsidian dev:debug on 2>/dev/null (once per session).
  • Always append 2>/dev/null to all obsidian CLI commands to suppress GTK/Electron warnings.
  • Always use the IIFE + console.log pattern for async eval: obsidian eval code="(async()=>{const r=await ...;console.log(JSON.stringify(r))})()" 2>/dev/null
  • obsidian eval only captures output logged within ~5–15 ms. Slow work prints nothing — that is not an error. Stash to a global and read it back with a second, synchronous eval.
  • JSON.stringify throws on status.refresh (circular PublishFile refs). Log a projection; snapshot() is always safe.
  • If window.__QS__ is undefined, the plugin may be running a production build without ENABLE_DEVELOPER_TOOLS. Rebuild with npm run build:dev and reload. If still unavailable, fall back to direct app.plugins.plugins['quartz-syncer'] access for raw state inspection.

When to Activate

Activate when:

  • The plugin produces errors after a code change
  • A feature doesn't work as expected in the running instance
  • The health check fails after reload
  • The status bar shows "error" state
  • Publish operations fail
  • UI doesn't render or renders incorrectly

Workflow

Step 1: Collect failure bundle

Always start by capturing the current state before any investigation changes it:

bash
obsidian eval code="JSON.stringify(window.__QS__.snapshot())" 2>/dev/null
obsidian eval code="JSON.stringify(window.__QS__.events.tail(20))" 2>/dev/null
obsidian dev:errors 2>/dev/null
obsidian dev:console level=error 2>/dev/null
obsidian dev:screenshot path=/tmp/debug.png 2>/dev/null

Save these outputs — they're the baseline for investigation.

Step 2: Analyze the snapshot

Parse the snapshot JSON and check:

  • plugin.loaded — false means the plugin failed to initialize
  • engine.running — false means the background engine didn't start
  • statusBar.state — "error" means something went wrong
  • errors.count — non-zero means errors occurred
  • errors.latest — the most recent error message
  • settings.configured — false means no repo configured
  • publisher.available — false means Publisher couldn't be created
  • publisher.lastError — the last publisher error
Step 3: Analyze events

Parse the event buffer and look for:

  • error.occurred events — check payload.error and payload.action
  • compilation.failed events — check payload.path and payload.error
  • publish.failed / delete.failed — check payload.error
  • engine.stopped without engine.started — abnormal shutdown

Events are ordered by cursor (monotonically increasing). Most recent events are at the end of the tail() result.

Show full SKILL.md (247 more words)Show less
Step 4: Check console errors
bash
obsidian dev:console level=error 2>/dev/null

Look for:

  • Stack traces — identify the source file and line number
  • TypeError — null/undefined access, often indicates initialization order issues
  • NetworkError — Git/HTTP failures
  • Plugin-specific errors prefixed with Quartz Syncer:
Step 5: Targeted investigation

Based on what Step 2-4 revealed:

Plugin won't load:

bash
obsidian eval code="typeof window.__QS__" 2>/dev/null
# "undefined" means facade didn't mount — check if ENABLE_DEVELOPER_TOOLS is set
obsidian eval code="app.plugins.plugins['quartz-syncer']?.settings?.ENABLE_DEVELOPER_TOOLS" 2>/dev/null

Publisher unavailable:

bash
obsidian eval code="app.plugins.plugins['quartz-syncer']?.settings?.gitRemoteUrl" 2>/dev/null
obsidian eval code="app.plugins.plugins['quartz-syncer']?.settings?.gitAuthType" 2>/dev/null

Compilation failures:

bash
obsidian eval code="JSON.stringify(window.__QS__.events.tail(50).filter(e => e.type === 'compilation.failed'))" 2>/dev/null

Connection failures:

bash
obsidian eval code="(async()=>{const r=await window.__QS__.act({name:'connection.test'});console.log(JSON.stringify(r))})()" 2>/dev/null

UI not rendering:

bash
obsidian dev:dom selector='[data-qs="pub-center"]' total 2>/dev/null
obsidian dev:dom selector='[data-qs="statusbar"]' total 2>/dev/null
obsidian dev:dom selector='.modal' total 2>/dev/null

Stale status:

bash
obsidian eval code="JSON.stringify(window.__QS__.snapshot().publishStatus?.stale)" 2>/dev/null
# If true, status needs refresh:
obsidian eval code="(async()=>{const r=await window.__QS__.act({name:'status.refresh'});console.log(JSON.stringify({success:r.success,counts:{unpublished:r.data.unpublished.length,changed:r.data.changed.length,published:r.data.published.length,deleted:r.data.deleted.length}}))})()" 2>/dev/null
Step 6: Wait for conditions

Use waitFor to monitor async conditions:

bash
# Wait for engine to become idle (compilation to finish)
obsidian eval code="(async()=>{const r=await window.__QS__.waitFor('engine.idle',{},10000);console.log(JSON.stringify(r))})()" 2>/dev/null

# Wait for no errors since a cursor
obsidian eval code="(async()=>{const r=await window.__QS__.waitFor('errors.none',{cursor:0},5000);console.log(JSON.stringify(r))})()" 2>/dev/null
Step 7: Mobile-specific debugging
bash
# Enable mobile emulation
obsidian eval code="(async()=>{const r=await window.__QS__.act({name:'env.emulateMobile',params:{enabled:true,confirm:true}});console.log(JSON.stringify(r))})()" 2>/dev/null

# Take screenshot in mobile mode
obsidian dev:screenshot path=/tmp/mobile-debug.png 2>/dev/null

# Check if desktop-only features are properly hidden
obsidian dev:dom selector='[data-qs="pub-center"]' total 2>/dev/null

# Disable emulation when done
obsidian eval code="(async()=>{const r=await window.__QS__.act({name:'env.emulateMobile',params:{enabled:false,confirm:true}});console.log(JSON.stringify(r))})()" 2>/dev/null

MUST DO

  • Always append 2>/dev/null to all obsidian CLI commands.
  • Always use the IIFE + console.log pattern for async eval calls.
  • Always collect the failure bundle FIRST — before any investigation that might change state.
  • Parse JSON responses systematically — don't eyeball large outputs.
  • Check BOTH the facade (window.__QS__) AND the console (dev:console) — some errors only appear in one.
  • If window.__QS__ is undefined, fall back to direct app.plugins.plugins['quartz-syncer'] access.
  • Report findings with specific error messages, event cursors, and file paths.

MUST NOT DO

  • Do NOT omit 2>/dev/null — GTK warnings pollute output parsing.
  • Do NOT use top-level await in eval — use the IIFE pattern.
  • Do NOT conclude an action failed because eval printed nothing — confirm with a synchronous follow-up query first.
  • Do NOT start changing code before understanding the root cause.
  • Do NOT ignore console errors even if the facade reports no errors — they may come from different sources.
  • Do NOT assume the plugin is broken if the facade is unavailable — check if ENABLE_DEVELOPER_TOOLS is enabled.
  • Do NOT run destructive operations (publish, delete) while investigating — use dry-run mode instead.

© saberzero1, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .agents/skills/debug-obsidian of saberzero1/quartz-syncer.

Open the folder on GitHubat commit 8f04c08

Compare with similar skills

Debug Obsidian next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Debug Obsidian compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Debug Obsidian this skillsaberzero1/quartz-syncer139—~1.9kAutomated safety check: PassMIT
OpenLogi macOS Permissions TriageAprilNEA/OpenLogi23k—~2.5kAutomated safety check: NotesApache-2.0
Bug Finder for daisyUIsaadeghi/daisyui43k—~2.3kAutomated safety check: PassMIT
Root Cause Debugginggarrytan/gstack136k—~1.4kAutomated safety check: PassMIT
Graph-Based Bug Tracingtirth8205/code-review-graph32k1 repos~287Automated safety check: PassMIT
Systematic DebuggingChrisWiles/claude-code-showcase6.1k3 repos~1.2kAutomated safety check: PassNone

Similar skills

  • OpenLogi macOS Permissions Triage

    AprilNEA/OpenLogi

    Decides whether an OpenLogi device problem on macOS is a privacy-permission (TCC) problem, using agent log lines, and says which identity needs which grant.

    23k GitHub stars~2.5k tokensUpdated 4 days ago
    DevelopmentAuto-check: notes

  • Bug Finder for daisyUI

    saadeghi/daisyui

    Investigates suspected bugs in the daisyUI monorepo through read-only analysis, then writes a decision-ready fix plan in tmp/bugs without changing any product code.

    43k GitHub stars~2.3k tokensUpdated 7 days ago
    DevelopmentAuto-check passed

  • Root Cause Debugging

    garrytan/gstack

    Investigates bugs, errors and stack traces in phases and requires a root-cause hypothesis to be confirmed before any fix is written.

    136k GitHub stars~1.4k tokensUpdated today
    DevelopmentAuto-check passed

  • Graph-Based Bug Tracing

    tirth8205/code-review-graph

    Traces a bug through a code knowledge graph, following callers, callees and execution flow before opening source files, within a small token budget.

    32k GitHub starsUsed in 1 repo~287 tokens
    DevelopmentAuto-check passed

  • Systematic Debugging

    ChrisWiles/claude-code-showcase

    Applies a four-phase debugging routine that finds the root cause of a bug or failing test before any fix is written.

    6.1k GitHub starsUsed in 3 repos~1.2k tokens
    DevelopmentAuto-check passed

  • Debugging and Error Recovery

    addyosmani/agent-skills

    Applies a stop-the-line rule and a step-by-step triage when tests fail, builds break or something stops working, aiming at the root cause instead of guesses.

    102k GitHub starsUsed in 1 repo~2.6k tokens
    DevelopmentAuto-check passed

More from saberzero1/quartz-syncer

  • Verify Changes

    saberzero1/quartz-syncer

    Post-change verification workflow — build, reload plugin in Obsidian, run health checks, and verify no regressions via the operability facade.

    139 GitHub stars~2.1k tokensUpdated 7 days ago
    Auto-check passed

  • Verify Publish

    saberzero1/quartz-syncer

    End-to-end publish verification — refresh status, publish files, verify the result, and confirm status changes via the operability facade.

    139 GitHub stars~1.6k tokensUpdated 7 days ago
    Auto-check passed

  • Verify UI

    saberzero1/quartz-syncer

    UI verification workflow — open modals, query DOM contract selectors, interact with inputs, take screenshots, and validate UI rendering via the operability facade.

    139 GitHub stars~2.3k tokensUpdated 7 days ago
    Auto-check passed

Works with

Categories

Questions about Debug Obsidian

What does Debug Obsidian do?

Debug and investigate plugin issues in a running Obsidian instance — collect diagnostic data, inspect state, trace events, and identify root causes via the operability facade. Debug Obsidian is an agent skill from saberzero1/quartz-syncer. Debug and investigate plugin issues in a running Obsidian instance — collect diagnostic data, inspect state, trace events, and identify root causes via the operability facade.

When should I use Debug Obsidian?

Debug Obsidian fits situations like: tasks that involve Root cause analysis; tasks that involve Debugging.

How do I install Debug Obsidian in Claude Code?

Run `npx skills add saberzero1/quartz-syncer --skill debug-obsidian -a claude-code`. Or copy the skill folder (.agents/skills/debug-obsidian in saberzero1/quartz-syncer) into .claude/skills/debug-obsidian in your project. Claude Code loads it when a task matches its description.

How do I install Debug Obsidian in Codex?

Run `npx skills add saberzero1/quartz-syncer --skill debug-obsidian -a codex`. Or copy the skill folder (.agents/skills/debug-obsidian in saberzero1/quartz-syncer) into .agents/skills/debug-obsidian in your project. Codex loads it when a task matches its description.

Can I use Debug Obsidian in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add saberzero1/quartz-syncer --skill debug-obsidian -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/debug-obsidian, .gemini/skills/debug-obsidian, .github/skills/debug-obsidian and .opencode/skills/debug-obsidian in your project.

What does Debug Obsidian need to run?

Going by SKILL.md and its folder, Debug Obsidian needs the command-line tools its instructions call (npm).

Does Debug Obsidian access the network?

SKILL.md contains no URLs. Its commands use npm, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Debug Obsidian safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Debug Obsidian use?

Debug Obsidian is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Debug Obsidian use?

About 1.9k tokens (SKILL.md is roughly 7.8k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Debug Obsidian?

Skills that share tags, products or a category with Debug Obsidian: OpenLogi macOS Permissions Triage (AprilNEA/OpenLogi, 23k stars), Bug Finder for daisyUI (saadeghi/daisyui, 43k stars), Root Cause Debugging (garrytan/gstack, 136k stars) and Graph-Based Bug Tracing (tirth8205/code-review-graph, 32k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Debug Obsidian?

saberzero1 (a GitHub user) maintains it in saberzero1/quartz-syncer, which has 139 GitHub stars. The repository holds 4 skills in this directory. The repository was last updated on September 30, 2026.

Source: saberzero1/quartz-syncer on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.