New: 98,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

Verify Publish

by saberzero1 in saberzero1/quartz-syncer

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

MITAuto-check passed

Install Verify Publish

skills CLI
$ npx skills add saberzero1/quartz-syncer --skill verify-publish -a claude-code

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

GitHub CLI
$ gh skill install saberzero1/quartz-syncer verify-publish --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/verify-publish .claude/skills/verify-publish && 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
verify-publish
GitHub stars
140
Token cost
~1.6k tokens
SKILL.md length
571 words
Files
1
Skills in repo
4
Repo updated
First seen
Licence
MIT

At a glance

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

  • Works in 7 steps: Verify prerequisites → Refresh publish status → Test connection → …
  • SKILL.md covers Purpose, When to Activate, Prerequisites and Workflow, plus 3 more sections
  • Calls npm

What it does

Verify Publish is an agent skill from saberzero1/quartz-syncer. End-to-end publish verification — refresh status, publish files, verify the result, and confirm status changes via the operability facade.

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

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.

Example prompts

  • “/verify-publish”

Workflow steps

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

  1. Verify prerequisites
  2. Refresh publish status
  3. Test connection
  4. Publish
  5. Verify result
  6. Check events
  7. Check for errors

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

Verify Publish loads about 1.6k tokens when it runs. Until then it costs about 38 tokens; SKILL.md has 571 words of instructions outside code blocks.

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

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). 571 words, ~1,562 tokens.

Download SKILL.mdSave it as .claude/skills/verify-publish/SKILL.md (or your agent's skills folder).
name
verify-publish
description
End-to-end publish verification — refresh status, publish files, verify the result, and confirm status changes via the operability facade.
triggers
verify publish, test publish, publish flow, does publish work, end to end
argument-hint
[file-path]

Verify Publish Skill

Purpose

Verify the full publish pipeline works end-to-end: status computation, file compilation, Git push, and status update. Uses the operability facade for structured verification rather than manual Obsidian interaction.

When to Activate

Activate when:

  • Changes were made to Publisher, PublishStatusManager, BundledGitBackend, or SyncerPageCompiler
  • Changes were made to the publication center UI that affect the publish flow
  • An agent needs to confirm a publish operation completed successfully
  • Testing after Git/auth configuration changes

Prerequisites

  • Obsidian must be running with the test vault open.
  • Plugin must be built with npm run build:dev (copies to test vault, enables facade via __DEV__ flag).
  • Facade must be available (obsidian eval code="typeof window.__QS__" 2>/dev/null returns => object).
  • Console capture requires obsidian dev:debug on 2>/dev/null (once per session).
  • Plugin must be loaded and healthy (assert('health.core') passes).
  • Repository must be configured (assert('health.configured') passes).
  • At least one file must be marked with publish: true in frontmatter.

Workflow

Step 1: Verify prerequisites
bash
obsidian eval code="JSON.stringify(window.__QS__.assert('health.core'))" 2>/dev/null
obsidian eval code="JSON.stringify(window.__QS__.assert('health.configured'))" 2>/dev/null

Both must return {"pass":true,...}. If health.configured fails, the repo is not set up — use obsidian quartz-syncer:config to configure.

Step 2: Refresh publish status
bash
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

Expected: {"success":true}. Then check the snapshot:

bash
obsidian eval code="JSON.stringify(window.__QS__.snapshot().publishStatus)" 2>/dev/null

This shows counts of unpublished, changed, published, deleted files. If unpublished and changed are both 0, there's nothing to publish.

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

Expected: {"success":true,"data":{"readAccess":true,"writeAccess":true}}. If write access is false, credentials may be wrong.

Step 4: Publish

Publishing pushes over the network, so it will normally outlast the ~5–15 ms eval capture window and print nothing. Stash the result and read it back, rather than relying on the inline log:

bash
obsidian eval code="window.__pub='pending';(async()=>{try{const r=await window.__QS__.act({name:'pub.publish',params:{message:'Test publish',confirm:true}});window.__pub=JSON.stringify({success:r.success,data:r.data,error:r.error})}catch(e){window.__pub=JSON.stringify({thrown:String(e)})}})()" 2>/dev/null
sleep 15
obsidian eval code="window.__pub" 2>/dev/null

Expected: {"success":true,"data":{"filesPublished":N,"filesDeleted":0,...}}. If success is false, check the error message. If it still reads pending, the publish has not finished — wait longer rather than re-running it.

The same applies to connection.test in Step 3: on a slow network it prints nothing. That is not a failure — stash and re-read it the same way.

Step 5: Verify result

Refresh status again and confirm file counts changed:

bash
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
obsidian eval code="JSON.stringify(window.__QS__.snapshot().publishStatus)" 2>/dev/null

The unpublished and changed counts should have decreased (or be 0). The published count should have increased.

Show full SKILL.md (236 more words)Show less
Step 6: Check events
bash
obsidian eval code="JSON.stringify(window.__QS__.events.tail(5))" 2>/dev/null

Look for publish.completed event with commitSha in the payload. This confirms the Git push succeeded.

Step 7: Check for errors
bash
obsidian dev:errors 2>/dev/null
obsidian dev:console level=error 2>/dev/null

No errors should be present.

Dry-run Alternative

To test the pipeline without actually pushing to the remote:

bash
obsidian quartz-syncer:publish dry-run 2>/dev/null

This uses the CLI dry-run flag which shows what would be published without making changes.

MUST DO

  • Always append 2>/dev/null to all obsidian CLI commands.
  • Always use the IIFE + console.log pattern for async facade calls.
  • Always refresh status before and after publish — status is cached and must be explicitly refreshed.
  • Always check the success field in action results — don't assume success.
  • Always stash-and-re-read results for network operations (pub.publish, connection.test); their output does not survive the eval capture window.
  • Always test connection before publish — avoids wasting time on auth failures.
  • Check events after publish for the commitSha — this confirms the push actually reached the remote.

MUST NOT DO

  • Do NOT publish without checking health.configured first — it will fail with an unclear error.
  • Do NOT skip the post-publish status refresh — without it, the snapshot still shows stale data.
  • Do NOT run publish in rapid succession — wait for each operation to complete before starting another.
  • Do NOT omit 2>/dev/null — GTK warnings will pollute output.
  • Do NOT use top-level await in eval — use the IIFE pattern.
  • Do NOT re-run a publish because it printed nothing — confirm via window.__pub, snapshot(), or the event buffer first. Re-running risks a second commit.

© 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/verify-publish of saberzero1/quartz-syncer.

Open the folder on GitHubat commit 8f04c08

Compare with similar skills

Verify Publish 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.

Verify Publish compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Verify Publish this skillsaberzero1/quartz-syncer140—~1.6kAutomated safety check: PassMIT
Obsidian BasesAtmosphere/atmosphere3.8k22 repos~3.2kAutomated safety check: PassApache-2.0
Knap Markdown Templateskepano/obsidian-skills49k2 repos~986Automated safety check: PassMIT
JSON Canvasheyitsnoah/claudesidian2.6k18 repos~3.5kAutomated safety check: PassMIT
Obsidian MarkdownAtmosphere/atmosphere3.8k20 repos~1.3kAutomated safety check: PassApache-2.0
Bounded AutoresearchAgriciDaniel/claude-obsidian15k1 repos~1.6kAutomated safety check: PassMIT

Similar skills

  • Obsidian Bases

    Atmosphere/atmosphere

    Create and edit Obsidian Bases (.base files) with views, filters, formulas, and summaries.

    3.8k GitHub starsUsed in 22 repos~3.2k tokens
    Backend & APIsAuto-check passed

  • Knap Markdown Templates

    kepano/obsidian-skills

    Renders Markdown notes from Knap templates and JSON data on the command line, including notes built from Defuddle web page output.

    49k GitHub starsUsed in 2 repos~986 tokens
    Documents & OfficeAuto-check passed

  • JSON Canvas

    heyitsnoah/claudesidian

    Create and edit JSON Canvas files (.canvas) with nodes, edges, groups, and connections.

    2.6k GitHub starsUsed in 18 repos~3.5k tokens
    DevelopmentAuto-check passed

  • Obsidian Markdown

    Atmosphere/atmosphere

    Create and edit Obsidian Flavored Markdown with wikilinks, embeds, callouts, properties, and other Obsidian-specific syntax.

    3.8k GitHub starsUsed in 20 repos~1.3k tokens
    Documents & OfficeAuto-check passed

  • Bounded Autoresearch

    AgriciDaniel/claude-obsidian

    Runs a bounded, source-grounded research loop that drafts a cited dossier and can propose a separately reviewed merge into an Obsidian vault.

    15k GitHub starsUsed in 1 repo~1.6k tokens
    Knowledge ManagementAuto-check passed

  • Obsidian CLI

    Atmosphere/atmosphere

    Interact with Obsidian vaults using the Obsidian CLI to read, create, search, and manage notes, tasks, properties, and more.

    3.8k GitHub starsUsed in 13 repos~795 tokens
    Knowledge ManagementAuto-check passed

More from saberzero1/quartz-syncer

  • Debug Obsidian

    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.

    140 GitHub stars~1.9k tokensUpdated 8 days ago
    Auto-check passed

  • 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.

    140 GitHub stars~2.1k tokensUpdated 8 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.

    140 GitHub stars~2.3k tokensUpdated 8 days ago
    Auto-check passed

Works with

Questions about Verify Publish

What does Verify Publish do?

End-to-end publish verification — refresh status, publish files, verify the result, and confirm status changes via the operability facade. Verify Publish is an agent skill from saberzero1/quartz-syncer. End-to-end publish verification — refresh status, publish files, verify the result, and confirm status changes via the operability facade.

How do I install Verify Publish in Claude Code?

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

How do I install Verify Publish in Codex?

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

Can I use Verify Publish 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 verify-publish -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/verify-publish, .gemini/skills/verify-publish, .github/skills/verify-publish and .opencode/skills/verify-publish in your project.

What does Verify Publish need to run?

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

Does Verify Publish 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 Verify Publish 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 Verify Publish use?

Verify Publish 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 Verify Publish use?

About 1.6k tokens (SKILL.md is roughly 6.2k 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 Verify Publish?

Skills that share tags, products or a category with Verify Publish: Obsidian Bases (Atmosphere/atmosphere, 3.8k stars), Knap Markdown Templates (kepano/obsidian-skills, 49k stars), JSON Canvas (heyitsnoah/claudesidian, 2.6k stars) and Obsidian Markdown (Atmosphere/atmosphere, 3.8k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Verify Publish?

saberzero1 (a GitHub user) maintains it in saberzero1/quartz-syncer, which has 140 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.