Z Skills accelerates and automates engineering work, adding guardrails and guidance to help Claude Code with various software development workflows. Its 23 skills assist with planning, building, testing, fixing, verifying, and shipping, turning many tasks into disciplined commands gated by review and verification. Six can run on a schedule, for unattended, round-the-clock output.
Branches, worktrees, commits, and pull requests are how work gets planned, verified, and landed — so a git-based project is assumed.
Install via the plugin marketplace (/plugin install zs@zskills, slash prefix /zs:) or the /update-zskills script (bare slash prefix) — full setup in the README.
/research-and-goThe full pipeline in one command. Decomposes a broad goal into sub-plans, drafts each with adversarial review, then executes all of them autonomously. One command, walk away.
/research-and-planDecomposes broad goals into focused sub-plans via domain research, dependency analysis, and scope bounding. Each sub-plan drafted upfront via /draft-plan; outputs a meta-plan for /run-plan.
/draft-planAdversarial plan drafting. Multiple agents research, draft, review, play devil's advocate, refine over up to 3 rounds. Scope check escalates to /research-and-plan when the task is too big. Optional brainstorm flag runs an interactive design dialogue first; optional quiz flag runs an interactive requirements interview first.
/refine-planRefine an in-progress plan. Reviews remaining phases against completed work, finds stale references and specification gaps, refines in place. Generates a Drift Log documenting how completed phases diverged from the original draft.
/draft-testsAppend a ### Tests subsection to each pending phase of an existing plan, via a senior-QE reviewer + devil's-advocate + refiner loop. Sister skill to /draft-plan, scoped to test specs; completed phases are checksum-gated and never modified.
/plansPlan dashboard. View index, find next ready plan, batch-execute.
/work-on-plansBatch-execute the prioritized ready queue from the dashboard. Reads .zskills/monitor-state.json and dispatches /run-plan sequentially across ready plans.
/run-planThe plan execution engine. Dispatches implementation in a worktree, verifies with a separate agent, updates progress, writes reports. Staleness check refreshes dependent plans. Rebase-before-commit for clean history. Supports finish mode and cron scheduling.
/doLightweight dispatcher for ad-hoc tasks. Worktree isolation, auto-push, cron scheduling. For work too small for /run-plan.
/verify-changesPre-commit quality gate. Reviews diffs, checks test coverage, runs all suites, manually verifies UI with playwright-cli, fixes problems, re-verifies until clean. Pre-existing failure protocol.
/qe-auditCommit audit: reviews recent commits for test gaps. Bash mode: adversarial stress-testing. Both file GitHub issues.
/manual-testing helperPlaywright-cli recipes with exact CSS selectors, event sequences, and auth bypass for browser-based verification.
/fix-issuesBatch bug-fixing sprints with auto-sync from GitHub. Prioritizes by severity, dispatches parallel worktree agents, collects results, auto-lands passing fixes. Supports cron for overnight execution.
/fix-reportInteractive companion to /fix-issues. Presents sprint results with diffs and test results. Every step ends with STOP AND WAIT for user judgment.
/investigateRoot-cause debugging: reproduce, trace, prove the cause with evidence, write regression test, then fix. No guessing.
/zskills-dashboardLocal web dashboard for plans, issues, worktrees, branches, and tracking activity. Drag-and-drop priority queue. start launches a detached Python server, stop SIGTERMs it, status reports uptime.
/session-reportAudit what THIS session said it would do vs. what's actually shipped. Verifies session-mentioned items against ground truth (git, PRs, plans, worktrees), not conversation memory — catches "I'll send a fix" turns that never happened.
/briefingProject status briefing: summary (triage), report (markdown), verify (sign-off items), current (in-flight), worktrees (cleanup readiness).
/commitInventories changes, classifies by scope, traces imports recursively, protects other agents' work. Pre-staging index check. Supports push and land modes.
/cleanup-mergedPost-PR-merge local normalization. Fetches origin with −−prune, switches off a feature branch whose PR merged, pulls main, deletes local feature branches whose upstreams are gone. Safe to run anytime; bails on a dirty tree.
/update-zskillsBootstrap the Z Skills system into a new project: copies skill files, configures settings, adapts instructions to the target codebase.
/land-pr helperPR landing helper — rebase, push, create-or-detect PR, poll CI, optional auto-merge. Dispatched by /run-plan, /commit pr, /do pr, and /fix-issues. user-invocable: false hides it from the / menu.
/create-worktree helperUnified worktree creation. Tier 1 caller (bash inside /run-plan, /fix-issues, /do) must pass --pipeline-id verbatim — the script rejects invocations without the flag (rc 5). Tier 2 user/Claude invocation works ad-hoc but is rarely needed in practice.
/research-and-go "Build me a recipe tracker."
Decomposes a broad goal into sub-plans, drafts each with adversarial review, then executes all of them autonomously. One command, walk away.
This workflow requires a bit of optimism.
The standard flow for a focused feature: draft a spec, execute phase by phase, verify. For broad goals, run /research-and-plan first to get sub-plans, then run them individually or as a metaplan via /run-plan.
Research, draft, review, devil's advocate. Up to 3 rounds.
Worktree agent implements each phase, verifies, lands.
Diff review, test coverage, manual test. Recursive until clean.
Or, to run a plan end-to-end in one shot: /run-plan PLAN.md finish auto.
/draft-tests pins down what "done" means per phase; /refine-plan catches stale references and invalidated assumptions before the next phase runs. Completed phases are checksum-gated and never re-touched.
Research, draft, adversarial review, devil's advocate. Iterates until convergence; outputs a plan file.
Append test specifications per pending phase. Senior-QE reviewer + devil's-advocate refinement loop.
Code lands. Dependencies move. Assumptions decay. Things change.
Reviews remaining phases against current code. Flags stale references and invalidated assumptions. Completed phases never modified.
Worktree agent implements next phase, verifies with separate agent, lands the work.
A self-running loop: a scheduled audit fills the queue with issues, scheduled fix-issues sprints drain it. Run the two on schedules in separate Claude Code sessions — one fills, one drains. Prioritize and watch progress in the dashboard.
Scheduled commit audit. Reviews recent commits for test gaps, edge cases, untested branches; files GitHub issues with reproduction recipes.
Scheduled sprint. Picks top-priority items from the dashboard queue. Parallel worktree agents, one per issue. Reproduce, fix, test, auto-land passing fixes.
Live local view of the loop: pending issues, running worktrees, recent landings. Drag-and-drop priority reorder.
Six skills support cron scheduling with a common API pattern.
| Skill | Example | What Gets Scheduled |
|---|---|---|
/run-plan |
/run-plan plans/FOO.md auto every 4h now |
One phase per cron fire, auto-advances to next |
/fix-issues |
/fix-issues 10 auto every 4h now |
Full sprint each fire (sync, prioritize, fix, land) |
/do |
/do Check docs every day at 9am |
Repeats the task description each fire |
/qe-audit |
/qe-audit every day at 9am now |
Commit audit + issue filing each fire |
/work-on-plans |
/work-on-plans 3 auto every 6h |
Execute next 3 ready plans each fire |
/briefing |
/briefing report 24h every day at 9am |
Daily briefing report |
| Flag | Meaning |
|---|---|
auto | Bypass user approval gates (implied by every) |
every <schedule> | 4h, 12h, day at 9am, weekday at 2pm |
now | Run immediately AND schedule (without now, only schedules) |
stop | Cancel the cron |
next | Show when the next fire is |
All crons are session-scoped (die when the session ends), self-deduplicating (new schedule replaces old), and self-perpetuating (each fire re-registers the cron).
Six patterns recur across the system.
| Pattern | What It Does |
|---|---|
| Worktree isolation | Built for parallel agent work: most skills can run the agent in its own git worktree (configurable). |
| Cron scheduling | every 2h, now, stop, next -- six skills self-schedule for autonomous execution. |
| Transcript-based hooks | The hook reads the session transcript (written by the runtime, not the agent) to verify tests actually ran. |
| Fresh-agent verification | The agent that wrote the code must not verify it. A separate agent with no memory audits diffs. |
| User gates | Critical decisions (landing code, closing issues) require explicit user approval. Skills STOP and wait. |
| Report generation | Persistent Markdown reports with sign-off checklists, screenshots, and verification instructions. |
Even with solid skills to guide them, agents need guardrails. The system uses a PreToolUse hook (block-unsafe.sh) that reads the session transcript to enforce key invariants:
| What's Enforced | How |
|---|---|
| Tests before committing code | Transcript must contain test runner invocation |
| Manual testing before committing UI changes | Transcript must contain playwright-cli |
| Tests before cherry-picking to main | Transcript must contain test runner invocation |
| No destructive git commands | git checkout --, git restore, git stash drop, git add . all blocked |
| No force pushes or kill commands | git push --force, rm -rf, kill -9 blocked |
| No piping test output | Blocks test commands with | -- must capture to file |
The hook runs on every Bash tool call. It reads the transcript (written by the Claude Code runtime, not the agent) so evidence cannot be fabricated.
Skills add softer enforcement at decision points: pre-landing checklists, verification timeouts (45 min for verifiers, 2h for implementers), and a Failure Protocol that kills crons and preserves state on errors.
23 core skills (21 user-facing + 2 helpers) that plan, build, test, fix, and ship — so one developer can run a full engineering team.
Z Skills System by Rich Conlan. Built with Claude Code (Claude Opus 4.6 / 4.7 / 4.8).