shipshitdev-library

Plugin shipshitdev-library from marketplace cascade-business-ops in joshuarweaver/cascade-business-ops. Commands read from the repo's manifest — 1 month ago.

Skills (192)

• readme-sync

  Regenerate catalog counts, layout claims, and README summaries from canonical sources. Run after adding, removing, or renaming skills, commands, or bundles. internal: true version: "1.1.0" tags: "readme, sync, maintenance, automation

• skill-auditor

  Audit the skills library for duplicates, stale content, spec violations, and structural issues. Run periodically or before releases. internal: true version: "1.2.1" tags: "audit, skills, quality, maintenance

• skill-validator

  Validate SKILL.md files against the Agent Skills spec and Claude Code extensions. Run on new or modified skills before committing. internal: true version: "1.0.3" tags: "validation, skills, spec-compliance, quality

• advanced-evaluation

  Design and operate LLM-as-a-Judge evaluation systems using direct scoring, pairwise comparison, rubric calibration, evaluator bias mitigation, confidence scoring, and automated quality assessment. Use when building LLM-as-judge systems, comparing model responses, calibrating rubrics, debugging incon

• agent-browser

  Automates browser interactions for web testing, form filling, screenshots, and data extraction. Use when the user needs to navigate websites, interact with web pages, fill forms, take screenshots, test web applications, or extract information from web pages.

• agent-dispatch

  Single front door for agent/subagent architecture, config, and setup. Parses a subcommand — audit, config, init, or route — and routes to the right engine: agent-architecture-audit (diagnose LLM wrapper and agent failures), agent-config-audit (audit and sync AI agent config files across workspaces),

• codex-image-gen

  Generate raster images (icons, illustrations, textures, app icons) from a text prompt by driving the Codex CLI's image tool, then extracting the finished PNG from the Codex session rollout. Use when an agent needs a real generated image and has no native image-generation tool. Requires the `codex` C

• comment-mode

  Granular feedback on drafts without rewriting. Generates highlighted HTML with click-to-reveal inline comments. Use when user says "comment on this", "leave comments on", "give feedback on", or asks for feedback on a draft. Supports multiple lenses—editor feedback, POV simulation ("as brian would re

• context-degradation

  Recognize, diagnose, and mitigate patterns of context degradation in agent systems. Use when context grows large, agent performance degrades unexpectedly, or debugging agent failures.

• context-engineering

  Supplementary context protocol for agents executing in a repo that has a CLAUDE.md / AGENTS.md (or equivalent config). Use to make an execution agent read project conventions first, treat inputs by trust level, surface plan-vs-convention conflicts instead of silently picking a side, and reuse existi

• context-fundamentals

  Explain or reason about foundational context engineering concepts: what context is, the anatomy of a context window, attention mechanics, the U-shaped attention curve, why context quality matters more than quantity, and the mental models needed to interpret context-engineering decisions. Use for con

• context-optimization

  Improve context efficiency through context budgeting, observation masking, prefix or KV-cache strategy, partitioning, token-cost reduction, retrieval scoping, and extending effective context capacity without lowering answer quality. Use when token costs or context budgets constrain a task, tool outp

• evaluation

  Build evaluation frameworks for agent systems. Use when testing agent performance, validating context engineering choices, or measuring improvements over time.

• mcp-builder

  Creates MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Activates on: "build an MCP server", "create MCP tools", "integrate API via MCP", "write a FastMCP server", "add an MCP server to an agent", or any request to wrap an externa

• memory-systems

  Design and implement memory architectures for agent systems that persist state across sessions, maintain entity consistency, and reason over structured knowledge. Use when building agents that persist knowledge across sessions, choosing between memory frameworks, maintaining entity consistency, or d

• multi-agent-patterns

  Design multi-agent architectures for complex tasks. Use when single-agent context limits are exceeded, when tasks decompose naturally into subtasks, or when specializing agents improves quality.

• prompt-engineering

  Expert guide on prompt engineering patterns, best practices, and optimization techniques. Use when user wants to improve prompts, learn prompting strategies, debug agent behavior, or design content generation prompts.

• skill-creator

  Guide for creating effective skills. Use when creating a new skill or updating an existing one to extend agent capabilities with specialized knowledge, workflows, or tool integrations.

• spec-first

  Coordinates preparation, prescribed implementation, independent review and verification using one shared issue contract. Use for nontrivial implementation that needs decisions settled before coding.

• tool-design

  Design tools that agents can use effectively, including when to reduce tool complexity. Use when creating, optimizing, or reducing the set of tools available to an agent.

• api-design-expert

  Expert in RESTful API design, OpenAPI/Swagger documentation, versioning, error handling, and API best practices for NestJS applications. Use when designing API endpoints, building RESTful APIs, writing OpenAPI/Swagger docs, implementing versioning, or designing error responses and DTOs.

• error-handling-expert

  Expert in error handling patterns, exception management, error responses, logging, and error recovery strategies for React, Next.js, and NestJS applications. Use when implementing error handling, exception filters, error responses, error logging, or recovery strategies.

• graphql-architect

  Design and review GraphQL schemas, resolvers, mutations, pagination, and data-loading patterns. Use when building or refactoring GraphQL APIs, adding fields, fixing resolver design, or improving GraphQL performance and safety.

• incremental-fetch

  Guides construction of resilient data ingestion pipelines from paginated APIs. Activates on: "ingest data from API", "pull tweets", "fetch historical data", "sync from X", "build a data pipeline", "fetch without re-downloading", "resume the download", "backfill older data". NOT for: simple one-shot

• nestjs-expert

  NestJS architecture, modules, DI, guards, interceptors, pipes, MongoDB/Mongoose integration, auth, and production patterns. Use when building NestJS APIs, designing module structure, implementing auth, handling errors, writing DTOs, or debugging NestJS-specific issues.

• nestjs-testing-expert

  NestJS testing mechanics with Jest — building testing modules, mocking providers and repositories, writing service and controller specs, and driving HTTP end-to-end tests through the real application. Use for any test touching a NestJS service, controller, guard, module, or API endpoint, including t

• turborepo

  Turborepo monorepo build system guidance. Triggers on: `turbo.json`, task pipelines, `dependsOn`, caching, remote cache, the `turbo` CLI, `--filter`, `--affected`, CI optimization, environment variables, internal packages, monorepo structure, and package boundaries. Use when the user configures task

• typescript-expert

  Resolves TypeScript and JavaScript problems across type-level programming, performance, monorepo management, migration, and modern tooling. Invoke when diagnosing "type instantiation excessively deep" errors, migrating JS to TS, configuring strict tsconfig, debugging module resolution, or choosing b

• typescript-refactor

  TypeScript refactoring and modernization guidelines from a principal specialist perspective. This skill should be used when refactoring, reviewing, or modernizing TypeScript code to ensure type safety, compiler performance, and idiomatic patterns. Triggers on tasks involving TypeScript type architec

• ask-dev-loop

  Ask which Dev Loop skill or flow fits the current situation. A router over the flagship idea-to-ship path.

• board-sync

  Reconciles a project board with current work and delivery evidence, reports incomplete coverage and metadata gaps, and applies only approved provider-supported field changes. Use when auditing board drift, reviewing blocked work, or assessing upcoming delivery.

• domain-modeling

  Build and sharpen a project's domain model. Use when discussing codebase terminology, writing or editing a CONTEXT.md, or recording or editing an ADR.

• executing-plans

  Executes a prepared GitHub issue without inventing product or engineering decisions, escalates plan gaps, and tracks delivery through independent cross-provider review, required CI, merge, and deployment evidence. Use when implementing an approved plan or processing an explicitly authorized issue qu

• feature-intake

  Coordinates a rough request into one complete, execution-ready issue by composing the shared requirements, planning, readiness, and issue-publishing engines. Use for /prd prepare or feature intake.

• grilling

  Grill the user relentlessly about a plan, decision, or idea. Use when the user wants to stress-test their thinking, asks to be grilled, or another skill needs the interview primitive.

• interview

  Repo-grounded discovery interview that produces a handoff brief for PRD writing, feature intake, or planning.

• prd-quality-gate

  Validates draft requirements and blocks execution until the same issue contains a complete, current implementation contract. Owns the shared preparation templates and readiness rules.

• prd-task-creator

  Publishes prepared requirements and implementation plans as one complete feature issue, with independently complete child outcomes only when justified. Reuses shared readiness and decomposition rules.

• prd-writer

  Authors repository-grounded requirements with complete feature scope and observable acceptance criteria. Reuses the canonical preparation contract; implementation planning is writing-plans.

• project-board

  Audits project board configuration and prepares explicitly requested setup, copy, or normalization changes while preserving the existing workflow and provider boundaries. Use when inspecting a board's fields, columns, scope, or configuration.

• qa-reviewer

  Runs a structured multi-phase verification pass on completed AI agent work — catching bugs, missed requirements, and incorrect assumptions before changes are committed. Triggers on: "check your work", "review this", after complex multi-step implementations, before committing major refactors, or proa

• setup-agent-routing

  Sets up an `## Agent skills` routing block in CLAUDE.md/AGENTS.md plus docs/agents/ so the dev-loop skills (executing-plans, feature-intake, prd-writer, qa-reviewer) know this repo's GitHub issue tracker, kanban label vocabulary, and domain doc layout. Run once per repo before first use of the loop,

• wait-what

  Re-pitch the last message in plain English using the project's CONTEXT.md vocabulary.

• writing-plans

  Resolves implementation decisions from researched requirements into an exact, current execution plan on the same issue. Use before handing coding to an executor that must escalate missing decisions.

• agent-architecture-audit

  Audit LLM and agent applications for wrapper regressions, prompt or memory contamination, tool discipline failures, hidden repair loops, and output rendering corruption. Use before shipping agent features or when an agent works in a direct model call but fails inside the product.

• agent-config-audit

  Audit AI agent instruction files (AGENTS.override.md, AGENTS.md, configured fallbacks, CLAUDE.md, hooks, and settings) across workspaces in read-only report mode. Use when agent configs drift, rules duplicate, files go stale, or after workspace restructuring; apply fixes only when explicitly request

• ai-agent-cost-optimizer

  Audit and reduce AI agent token and inference spend through context discipline, prompt caching, model routing, batching, and workflow capture. Use when discussing AI coding bills, token waste, model selection, prompt caching, or agent cost optimization.

• ai-regression-testing

  Design regression tests for AI-assisted development by targeting model blind spots such as sandbox versus production path drift, response-shape mismatches, untested bug fixes, and same-model review failures. Use after AI-generated code changes, bug fixes, API edits, or feature-flag/sandbox changes.

• changelog-generator

  Automatically creates user-facing changelogs from git commits by analyzing commit history, categorizing changes, and transforming technical commits into clear, customer-friendly release notes. Turns hours of manual changelog writing into minutes of automated generation. Use when preparing release no

• code-review

  Correctness, security, and spec-fidelity gate for incoming pull requests. Auto-invoked when reviewing a diff, evaluating a PR, running /code-review at any effort level, or asked "is this safe to merge?" Covers bugs, TypeScript hygiene, security, database safety, test existence, devex regressions, fe

• codebase-advisor

  Survey any codebase as a senior advisor, then hand back either prioritized self-contained implementation plans for OTHER models/agents to execute, or a written architecture and health analysis for humans. Strictly read-only on source code — never implements, fixes, or refactors anything itself. Use

• codebase-design

  Shared vocabulary for designing deep modules. Use when the user wants to design or improve a module's interface, find deepening opportunities, decide where a seam goes, make code more testable or AI-navigable, or when another skill needs the deep-module vocabulary.

• commit-summary

  Generate Conventional Commit messages from staged or unstaged git changes, split unrelated changes into logical commits, detect breaking changes, and optionally create commits after approval. Use when writing commit messages, preparing commits, or committing local work.

• debug

  Front door for a freshly reported failure: build a deterministic feedback loop, reproduce the symptom, rank falsifiable hypotheses, and instrument the narrowest point that separates them. Carries the lookup library — 54 rules across 10 categories covering observation technique, common bug patterns,

• deploy-dispatch

  Single front door for deployment and infra provisioning. Parses a subcommand — app, compose, ec2, monitor, or devcontainer — and routes to the right engine: deploy (web app deployment to staging/production), deployment-composer (compose the smallest safe deployment workflow from repo signals), ec2-b

• deploy

  Run deployment workflows for web applications (staging, production). Use when user says 'deploy', 'push to staging', 'release', 'ship it', or 'go live'.

• deployment-composer

  Compose deployment workflows from smaller skills and repo signals, including trunk-based releases, CI quality gates, provider deployment, post-deploy verification, rollback, and failed-check diagnosis. Use when the user asks for a deployment plan, release workflow, ship-to-staging/production environ

• deslop

  Strip AI-generated slop from a codebase, product, and prose. Code slop — console statements, `any` types, unused imports, commented-out code, redundant comments, needless defensive try-catch on trusted paths, over-nesting. Product slop (with --product) — marketing-filler copy, generic AI phrasing, d

• docs

  Creates clear, concise technical documentation for software projects, runbooks, and developer guides. Use when writing or updating a README, guide, runbook, API reference, setup instructions, or troubleshooting notes.

• execution-debugging

  Scoped debugging methodology for when a test or build fails during execution/stabilization. Use to diagnose the failing check without scope-creeping — read the full error, reproduce in isolation, hypothesize before changing, localize, fix the root cause not the symptom, and guard with a regression t

• full-code-review

  Fan-out PR review across three parallel dimension agents (structural, security, devex/flag-hygiene), adversarially verify every finding, and synthesize a single prioritized verdict via a strongest-tier judge. Use when asked for a full, comprehensive, or end-to-end review of a branch or PR — after /c

• git-cleanup

  Fetches trunk, then proves candidate file content reached trunk before planning or removing merged branches and worktrees. Defaults to a read-only cleanup plan.

• grok-review

  Independent second-opinion code review through the Grok CLI. Builds a self-contained review prompt from the exact diff, runs one headless Grok invocation on the CLI's own default model and effort, then verifies every returned finding against the code before reporting. Use when asked to review with G

• llm-structured-output

  Design prompts, schemas, validation, and recovery logic for reliable machine-readable model outputs. Use when generating JSON, typed objects, extraction results, tool arguments, or any output another system must parse safely.

• merge-open-prs

  Review and land open pull requests through one /merge command. The default mode runs a confirmation-gated trunk sweep and reports cleanup candidates; exact /merge force drains the queue non-serially by merging green PRs and narrowly fixing red PRs. Use when asked to review and merge open PRs, batch-

• production-audit

  Audit an application for production readiness using local evidence from code, CI, config, migrations, runtime checks, observability, and deployment paths. Use before launch, after risky merges, or when asked whether an app is ready to ship.

• receiving-code-review

  Evaluate incoming code-review feedback with technical rigor before implementing any change. Verify each point against the codebase, push back with reasoning when the reviewer is wrong, and never perform empty agreement. Use when you receive a review, before touching any code, especially when feedbac

• refactor-code

  Systematic approach to safely refactoring code with tests. Use when user says 'refactor', 'clean up code', 'simplify', 'reduce complexity', or 'technical debt'.

• refactor-dispatch

  Single front door for improving existing code — routes to the right engine by mode: deslop (strip AI slop, code + product), code (safe behavior-preserving refactor), debt (tech-debt register), perf (frontend + backend optimization), structure (read-only structural review), or stack (dependency + fra

• release-dispatch

  Single front door for releases. Parses a subcommand — gates, cut, or notes — and routes to the right release engine: release-pr-gates (verify CI green, then cut a tag/release or open a release PR) or release (semver bump + plain-English patch notes). Backs the /release command. Use when asked to rel

• release-pr-gates

  Holds a release at the gate — opens or reuses a release PR into the trunk, runs local format, lint, and type-check, watches required GitHub checks through to green, and summarizes the failing run's root cause when they are not. Tags only after the gate passes. Reach for it during the pre-merge wait;

• release

  Cuts the release itself — derives the next semantic version from commits since the last tag, writes plain-English patch notes, previews the plan, then on confirmation creates an annotated tag plus GitHub release, or dispatches the repo's guarded release workflow where production sits behind a workfl

• review-dispatch

  Single front door for code review. Resolves a target — working-tree changes, one PR, all open PRs, the last N commits, a time window, or a retrospective over merged history — into the right workflow, natively or through an external second-opinion engine (grok). Keeps every /review mode report-only e

• scaffold

  Generate incremental local code modules following existing codebase patterns. Use for endpoints, components, packages, collections, or modules inside an existing repo; not for full project scaffolds.

• shape

  Plan the UX and UI for a feature before writing code. Produces a design brief that guides implementation.

• skill-capture

  Extracts valuable workflows, patterns, and domain knowledge from conversations and persists them as reusable SKILL.md files. Triggers on: "save this as a skill", "capture this as a skill", "make this reusable", "this workflow should be reusable", "this was tricky to figure out", "I wish I knew this

• skill-comply

  Measure whether agents actually follow a skill, rule, command, or agent definition by deriving expected behaviors, running representative scenarios, and comparing observed action timelines against the spec. Use after adding or changing instructions, before publishing skills, or when rules appear to

• skill-dispatch

  Single front door for authoring and maintaining agent skills. Parses a subcommand — create, capture, comply, or scout — and routes to the right engine: skill-creator (guide for creating or updating a skill), skill-capture (extract a workflow from conversation into a SKILL.md), skill-comply (measure

• skill-scout

  Search local, marketplace, repository, package, GitHub, and web sources before creating a new skill or custom implementation. Use when asked to create, fork, import, or evaluate a skill, or before writing code for functionality that likely already exists.

• stack-modernization

  Modernize a project's stack — outdated dependencies, dead/unused packages, deprecated packages, and framework-pattern drift (old patterns lingering after a major upgrade). Verifies the current latest of each package before proposing an upgrade, then applies changes incrementally with tests between e

• standup
• structural-review
• systematic-debugging
• tech-debt
• verification-before-completion
• weekly-review
• wizard
• worktree
• accessibility
• ai-loading-ux
• audit
• clarify
• component-library
• critique
• design-consistency-auditor
• design-dispatch
• expo-architect
• frontend-design
• html-style
• landing-page-vercel
• layout
• micro-landing-builder
• nextjs-validator
• nextra-writer
• polish
• prototype
• quick-view
• quieter
• react-component-performance
• react-hook-form
• react-native-components
• react-patterns
• react-refactor
• react-testing-library
• shadcn-setup
• shadcn
• table-filters
• tailwind-validator
• tailwind
• theme-factory
• bug
• finishing-a-development-branch
• fix-merge-conflicts
• git-safety
• github-actions-author
• github-address-comments
• github-fix-ci
• github-inbox
• github-pr-publish
• github-review-suggestions
• pr-comments
• aws-infrastructure
• docker-expert
• ec2-backend-deployer
• mongodb-atlas-checker
• mongodb-migration-expert
• monitoring-setup
• nestjs-queue-architect
• performance-expert
• postgres-ops
• redis-caching
• security-expert
• vercel-deploy
• stripe-implementer
• cto-advisor
• icp
• prd-dispatch
• roadmap-analyzer
• roadmap-to-milestones
• rules-capture
• dependency-audit
• open-source-checker
• security-audit
• agent-folder-init
• workspace-performance-audit
• husky-test-coverage
• playwright-e2e-init
• qa-loop
• tdd
• test-dispatch
• test-runner
• testing-cicd-init
• testing-expert
• artifacts-builder
• biome-validator
• bun-validator
• clerk-validator
• content-script-developer
• devcontainer-setup
• env-setup
• fullstack-workspace-init
• linter-formatter-init
• package-architect
• project-init-orchestrator
• commands
• architect
• arena
• blast-radius
• create-verification-skill
• figure-it-out
• how
• interrogate
• maintain-verification-skill
• no-comments
• pstack
• recall
• setup-pstack
• show-me-your-work
• swarm
• teach
• technical-writing
• why

Slash commands (29)

• /shipshitdev-library:address
• /shipshitdev-library:agent
• /shipshitdev-library:ask
• /shipshitdev-library:board
• /shipshitdev-library:bug
• /shipshitdev-library:cleanup
• /shipshitdev-library:codex-loop
• /shipshitdev-library:deploy
• /shipshitdev-library:design
• /shipshitdev-library:deslop
• /shipshitdev-library:env
• /shipshitdev-library:feature
• /shipshitdev-library:fix-ci
• /shipshitdev-library:loop
• /shipshitdev-library:merge
• /shipshitdev-library:pr
• /shipshitdev-library:prd
• /shipshitdev-library:prompt
• /shipshitdev-library:qa
• /shipshitdev-library:refactor
• /shipshitdev-library:release
• /shipshitdev-library:review
• /shipshitdev-library:roadmap
• /shipshitdev-library:scan
• /shipshitdev-library:standup
• /shipshitdev-library:suggest
• /shipshitdev-library:test
• /shipshitdev-library:wait-what
• /shipshitdev-library:weekly-review

Similar plugins