workflow

Plugin workflow in nklisch/skills. Commands read from the repo's manifest — 12 days ago.

Skills (24)

• autopilot

  Autonomously execute a project roadmap end-to-end. Reads ROADMAP.md and foundation docs, then loops design -> implement-orchestrator -> test for each phase, with judgment-driven refactoring passes every 2-4 phases. Tracks progress for cross-session resumption. Use after /ideate and /roadmap when you

• bold-refactor

  Find beautiful code abstractions and cross-cutting simplifications. Applies conceptual lenses (elimination, unification, inversion) to surface bold architectural ideas, then converges into an implement-ready design document.

• cruft-cleaner

  Sweep a codebase for AI-accumulated cruft (dead code, stale comments, compatibility shims, defensive bloat, over-abstraction), triage findings by confidence tier, then orchestrate parallel cleanup agents with worktree isolation. Use when user says "clean cruft", "dead code", "unused code", "stale co

• design

  Create a detailed design document with typed implementation units. Use when a feature spans multiple files or modules, when scope is unclear before coding, when the user provides a vision or roadmap and wants a plan before implementation, or when implementing would require too many upfront decisions

• e2e-test-design

  Design a comprehensive end-to-end test suite for a project. Explores the codebase, understands user-facing behavior from docs and code, then designs two test sets: golden-path user journey tests and adversarial/failure-mode tests. Interactive — asks the user about expected failure behavior before fi

• extend

  Add capability to an existing project — handles both small one-off features and major scope expansions. Reads foundation docs, explores the codebase, then branches: small additions produce a feature brief that design consumes; large expansions update foundation docs and roadmap before designing. Use

• extract-patterns

  Discover and document reusable code patterns into .claude/skills/patterns/. Use after completing a significant feature, when repeated structures appear across files, when starting a new project phase and want to codify conventions, or when other agents would benefit from documented patterns for cons

• fix

  Diagnose and repair a specific bug or broken behavior. Reproduces the issue, bisects to the root cause, writes a failing test that captures the bug, applies the minimal fix, then confirms. Use when something is verifiably broken — not for unverified hunches, refactoring, or feature additions. Differ

• ideate

  Interactive project definition workshop. Explores an idea through discovery, refinement, and requirements phases, then produces tailored foundation documents (VISION.md, SPEC.md, ARCHITECTURE.md, and domain-specific docs) based on the project's actual needs. Use when defining what to build, formaliz

• implement-orchestrator

  Orchestrate implementation of a design or plan document by spawning Sonnet task agents. Use for large designs (20+ files) or designs with independent subsystems that benefit from parallel implementation. Opus reads the plan, splits work into agent-sized units, crafts focused prompts, and spawns Sonn

• implement

  Write code from a design or plan document. Use when a design, refactor plan, or refactoring plan exists and code needs to be written. Best for plans targeting fewer than ~20 files or with tightly coupled units. For larger or parallelizable work, use implement-orchestrator instead.

• perf-design

  Profile performance bottlenecks and design optimized solutions. Follows a strict optimization hierarchy: algorithmic fixes, I/O reduction, language idioms, then parallelism. Produces implementation-unit plans with benchmark scaffolds for implement or implement-orchestrator.

• principles

  Architectural and code-level principles (Ports & Adapters, Single Source of Truth, Generated Contracts, Fail Fast) plus the doc-discipline principle (Rolling-Foundation). Auto-loads when designing new modules, defining interfaces between layers, discussing system architecture, writing new functions

• refactor-conventions-creator

  Create or update a project-specific refactor-conventions skill. Explores the repo, researches stack-specific best practices, interviews the user about both stylistic preferences (early returns, error handling, paradigm, composition patterns) and structural preferences (file size, folder layout, modu

• refactor-design

  Plan incremental, safe refactoring. Use when duplicate logic has been found across files, when architectural violations exist (e.g. domain importing infrastructure), when quality-gate recommends structural improvements, or when a large area needs restructuring before further feature work. Do NOT use

• release

  Prepare and publish a release. Drafts changelog entries from recent commits, confirms with user, then runs the release script.

• repo-eval

  Multi-dimensional codebase evaluation with verified scoring. Launches parallel explore agents, cross-checks findings with direct verification, produces calibrated 1-10 scorecard across architecture, code quality, testing, documentation, CI/CD, error handling, security, DX, and maintainability with p

• research

  Research external libraries, APIs, SDKs, and patterns to inform design and implementation. Investigates options, evaluates trade-offs against project needs, and produces both a research document and an auto-loading reference skill. Use before designing features that depend on unfamiliar technology,

• review

  Review a specific code change — branch diff, commit, commit range, working tree, unpushed commits, or PR by number. Produces a structured review with Blockers, Important issues, and Nits. Different from /repo-eval (full repository audit) and /security-review (full repository, security domain only).

• roadmap

  Generate an agent-optimized project roadmap from foundation documents. Reads VISION, SPEC, ARCHITECTURE, and other docs produced by /ideate, interviews about build style, then decomposes into chunky phases with dependencies, deliverables, and test checkpoints. Use after /ideate or when a project nee

• security-review

  Comprehensive security audit for any codebase. Discovers stack, lets user choose focus domains (auth, injection, secrets, dependencies, API, infra, crypto, data protection, error handling), researches best practices, then produces scored markdown report with severity-classified findings. Use when us

• test-quality

  Improve test quality by deriving tests from specs, designs, and contracts — not from existing code. Use when you want to find gaps in test coverage, design tests for interfaces and behavioral contracts, or systematically cover edge cases and branches from a specification perspective.

• tool-evaluator

  Structured self-evaluation of agent tool usage in the current conversation. Analyzes confusion points, inefficiencies, missing capabilities, and API surface friction. Produces a prioritized .md report with actionable recommendations for tool authors. Use when user says "evaluate tools", "tool feedba

• update-documentation

  Align all documentation to code after a change. Use after implementing a feature, adding a config key, new CLI command, new flag, or any non-trivial code change. Invoke proactively when finishing implementation — not only when the user asks. Discovers the project's doc structure dynamically rather t

Subagents (1)

• Explore

  Codebase exploration agent that synthesizes findings into actionable answers. Use when you need to understand code architecture, find implementations, trace data flow, map dependencies, or answer questions about a codebase. Specify thoroughness: "quick" for targeted lookups, "medium" for moderate ex