zsl

Plugin zsl from marketplace zsl-superpowers in ZunoSmartLabs/zsl-superpowers. Commands read from the repo's manifest — 1 month ago.

Skills (32)

• ask-zsl

  Interactive router that helps you find the right ZSL skill for what you're doing right now, without leaving your work. Use when you're mid-session and unsure which skill fits — "which ZSL skill should I use", "how do I do X with these skills", or when you want to be routed to the right part of the l

• code-review

  Comprehensive pre-PR code review of the current branch with an issues-only tone and an approval gate before applying fixes. Use when user wants a code review, mentions /code-review, or asks to scan the branch before opening a PR.

• codebase-design

  Shared vocabulary and refinements for reasoning about module depth, interfaces, seams, and adapters — the deep-module design language. Use when discussing module/interface design, whether a module is deep or shallow, where to place a seam, how to design an interface for testability, or when explorin

• commit-push-pr

  Commit session changes, push the branch, and open a PR — in one shot. Refuses to run on the repo's default branch (main/master) so the PR step can't fail. Delegates the commit step to `/zsl:commit`, then pushes with `-u`, then opens the PR via `gh`. Use when user wants to ship a feature branch end-t

• commit

  Plan and create git commits autonomously for changes made in this session (no per-commit approval prompt). Cross-session dirty files — files modified outside this conversation's tool calls — get confirmed before inclusion. Explicit file lists only, never `git add -A`. No Claude attribution lines. Us

• decision-mapping

  Turn a loose, multi-session idea into a sequenced map of the decisions and tickets it implies, so it matures before becoming a PRD. Use at the front of the loop when an idea is still fuzzy, spans several sessions, or you want to see the decision dependencies and a rough build order before committing

• diagnose

  Disciplined diagnosis loop for hard bugs and performance regressions. Reproduce → minimise → hypothesise → instrument → fix → regression-test. Use when user says "diagnose this" / "debug this", reports a bug, says something is broken/throwing/failing, or describes a performance regression.

• domain-modeling

  The home for domain-doc reasoning — the CONTEXT.md Ubiquitous Language format, the ADR format, and the Domain-Driven Design book-rules. Use when capturing or sharpening a project's domain language, deciding whether a decision deserves an ADR, classifying subdomains, naming bounded-context relationsh

• git-branch

  Create a git branch with the prefix convention (`feature/`, `fix/`, `chore/`, `refactor/`, `env/`) required by GitHub auto-PR workflows. Use when user wants to start a branch, says "new branch", or asks to begin a feature.

• grill-with-docs

  Grilling session that challenges your plan against the existing domain model, sharpens terminology, and updates documentation (CONTEXT.md, ADRs) inline as decisions crystallise. Use when user wants to stress-test a plan against their project's language and documented decisions.

• human-itl

  Walk a human through the manual-action [HITL] sub-tasks of a parent (PRD) issue — the steps a coding agent physically cannot perform — recording each as an audit trail and marking them done so the dependent [AFK] slices unblock, then hand back to /tdd-parallel. Use when /tdd-parallel skipped HITL sl

• improve-codebase-architecture

  Find deepening opportunities in a codebase, informed by the domain language in CONTEXT.md and the decisions in docs/adr/. Use when the user wants to improve architecture, find refactoring opportunities, consolidate tightly-coupled modules, or make a codebase more testable and AI-navigable.

• prototype

  Build a throwaway prototype to flush out a design before committing to it. Routes between two branches — a runnable terminal app for state/business-logic questions, or several radically different UI variations toggleable from one route. Use when the user wants to prototype, sanity-check a data model

• setup-zsl-superpowers

  Sets up an `## Agent skills` block in AGENTS.md/CLAUDE.md and `docs/agents/` so the engineering skills know this repo's issue tracker (GitHub, local markdown, or a hybrid local-markdown-plus-GitHub-mirror), triage label vocabulary, domain doc layout, ship style (PR vs direct push), and — optionally

• tdd-parallel

  Full-auto PRD pipeline. Fans out the unblocked [AFK] sub-tasks of a parent PRD into parallel /tdd sub-agents, integrates them onto the PRD branch, auto-chains /verify-coverage to prove every user story has a passing non-vacuous test, auto-fixes any gaps (loop), then opens a single integration PR. Ru

• tdd

  Test-driven development with red-green-refactor loop. Use when user wants to build features or fix bugs using TDD, mentions "red-green-refactor", wants integration tests, or asks for test-first development.

• teach-me-the-codebase

  On-the-fly conversational tutor that teaches you an unfamiliar repo's domain, architecture, and conventions interactively — reading the canonical docs and code, never writing them. Use when onboarding to a new codebase, when you ask to be taught or walked through how a repo works, or when you want t

• to-issues

  Break a plan, spec, or PRD into independently-grabbable issues on the project issue tracker using tracer-bullet vertical slices. Use when user wants to convert a plan into issues, create implementation tickets, or break down work into issues.

• to-prd

  Turn the current conversation context into a PRD and publish it to the project issue tracker. Use when user wants to create a PRD from the current context.

• triage

  Triage issues through a state machine driven by triage roles. Use when user wants to create an issue, triage issues, review incoming bugs or feature requests, prepare issues for an AFK agent, or manage issue workflow.

• verify-coverage

  Verify every PRD user story is covered by a passing, non-vacuous behavioral test — Tier A maps to an existing test; Tier B generates one, mutation-proves it, and runs it. Auto-files gaps as new sub-issues and writes a coverage receipt. Used as `/tdd-parallel`'s step-4b subroutine in `--auto` mode (t

• edit-article

  Edit and improve articles by restructuring sections, improving clarity, and tightening prose. Use when user wants to edit, revise, or improve an article draft.

• setup-pre-commit

  Set up Husky pre-commit hooks with lint-staged (Prettier), type checking, and tests in the current repo. Use when user wants to add pre-commit hooks, set up Husky, configure lint-staged, or add commit-time formatting/typechecking/testing.

• steampipe

  Use when querying AWS infrastructure via Steampipe. Provides correct table names, column schemas, and query patterns.

• grill-me

  Interview the user relentlessly about a plan or design until reaching shared understanding, resolving each branch of the decision tree. Use when user wants to stress-test a plan, get grilled on their design, or mentions "grill me".

• grilling

  The shared design-tree interview protocol — the status markers, the example tree, the reprint rules, and the node status-lifecycle. Use when running or structuring a relentless one-question-at-a-time interview that walks a decision tree to resolve every branch of a plan or design. Composed by grill-

• handoff

  Compact the current conversation into a handoff document so a fresh agent (or session) can continue the work cleanly. Saves to the OS temp directory, redacts secrets, references existing artifacts by path instead of duplicating them, and suggests which skills the next session should invoke. Use when

• timesheet

  Summarize recent Claude Code sessions, Granola meetings, calendar events and sent email into timesheet bullets grouped by customer, then propose and log the matching Harvest time entries. Use when the user asks "what did I do today", wants a timesheet entry, daily standup notes, a summary of recent

• writing-great-skills

  Principles and vocabulary for authoring great agent skills — progressive disclosure, sharp descriptions/triggers, when to bundle scripts, and the structure that keeps SKILL.md small. Use when writing, designing, reviewing, or improving a skill, or when asked how to make a skill fire reliably.

• afk-fanout

  Interactive local-session scheduler for overnight remote /tdd-parallel runs. Reviews the queue of tracking PRDs with ready-for-agent children, lets the human pick which to run overnight and in what order, then schedules one one-shot remote routine per selected PRD spaced a fixed 2h apart — each fire

• afk-worker

  Remote per-PRD executor fired by an /afk-fanout-scheduled one-shot routine. Runs unattended in its own remote claude.ai session — own clone, own working tree, own branch — so it never contends with other PRDs' workers. Flips the PRD's scheduled claim to in-progress, runs /tdd-parallel <num> --on-rev

• morning-review

  Walk a human through the overnight artifacts the /afk-worker routines (scheduled by /afk-fanout) produced. First reconciles the shared afk-runs ledger branch into the canonical .scratch/ tracker — replaying claim flips and halt RCAs that ran in isolated worker clones — across every un-reconciled run