Software Engineering

Plugin software from marketplace skill-marketplace in MattMakes/skill-marketplace. Commands read from the repo's manifest — 6 days ago.

Skills (142)

• adhd

  Parallel divergent ideation for coding agents. Spawns N isolated branches under different cognitive frames (regulator, biology, speedrunner, 10-year-old, $0 budget), scores, clusters, prunes traps, and deepens top survivors. Use on /adhd, "ADHD mode", brainstorm/ideate intents, or open-ended design,

• advanced-elicitation

  Push the LLM to reconsider, refine, and improve its recent output. Use when user asks for deeper critique or mentions a known deeper critique method, e.g. socratic, first principles, pre-mortem, red team

• adversarial-ux-test

  Roleplay the most difficult, tech-resistant user for your product. Browse the app as that persona, find every UX pain point, then filter complaints through a pragmatism layer to separate real problems from noise. Creates actionable tickets from genuine issues only. Use when asked for an adversarial

• agent-memory

  Use when a project's CLAUDE.md has grown past what anyone reads and you want the agent to learn durable facts from its own sessions instead — or when asking why the agent keeps re-learning the same correction, why a remembered rule is wrong, or where a memory line came from. Implements a four-tier s

• agent-security-hardening

  Security hardening guidance for AI agent frameworks that process untrusted content, invoke tools, write workspace files, manage runtime identifiers, or handle credentials. Use when building or reviewing an agent runtime, autonomous worker, tool gateway, memory service, or multi-tenant agent deployme

• ai-debt-detector

  Targeted audit for the debt AI-generated code hides: missing failure modes, orphaned resources, unhandled edge cases, hallucinated dependencies and architectural drift, with red flags to stop on. Use after generating code, after accepting AI suggestions, when reviewing AI-written modules, when code

• ai-development-guide

  Applies language-agnostic and backend technical decision criteria, anti-pattern detection, debugging, and quality gates. Use when reviewing general/backend implementation choices, code smells, failures, or implementation completeness.

• analyze-design

  Analyze designs from 8 expert perspectives simultaneously using specialized sub-agents, plus a ninth user-experience and accessibility perspective when the design has a user interface

• animation

  Animation and motion for the web and video: GreenSock's official GSAP guides (core tweens and easing, timelines, ScrollTrigger, plugins such as Flip, Draggable, SplitText and ScrollSmoother, gsap.utils, React with useGSAP, and Vue, Nuxt and Svelte), a three-layer motion/react system for React and Ne

• api-design-principles

  Master REST and GraphQL API design principles to build intuitive, scalable, and maintainable APIs that delight developers. Use when designing new APIs, reviewing API specifications, or establishing API design standards.

• api-design-reviewer

  Comprehensive REST API design review with automated linting, breaking-change detection, and design scorecards. Catches inconsistent conventions, missing versioning, and design smells before APIs ship. Use when reviewing a PR that adds or changes API endpoints, auditing an existing API for v2 migrati

• architect

  Sketch types, signatures, and module structure before code, then stay in the loop while implementation fills in. Use for /architect, 'architect this', 'design this', or non-trivial work where jumping to code would lock in the wrong shape.

• architecture-decision-records

  Write and maintain Architecture Decision Records (ADRs) following best practices for technical decision documentation. Use when documenting significant technical decisions, reviewing past architectural choices, or establishing decision processes.

• arena

  Spawn N parallel candidates at the same task, pick a base, graft the strongest parts of the losers into it. Use for /arena, 'arena this', 'throw it in the arena', or when one attempt at a non-trivial artifact would lock in the wrong shape.

• bats-testing-patterns

  Master Bash Automated Testing System (Bats) for comprehensive shell script testing. Use when writing tests for shell scripts, CI/CD pipelines, or requiring test-driven development of shell utilities.

• benchmark-checklist

  Vet a perf measurement (limiter, tuning, limits, errors, repeatability, relevance, and whether the work happened) before you report or act on it. Use when you run a benchmark or report a speedup or regression you measured.

• blast-radius

  Find what a change could break somewhere else before it ships, beyond the diff, and prove the one fact it's safe because of by running real code instead of writing it up. Use for 'blast radius of X', 'what could this break', or reviewing a small diff you don't trust.

• block-no-verify-hook

  Configure a PreToolUse hook to prevent AI agents from skipping git pre-commit hooks with --no-verify and other bypass flags. Use when setting up Claude Code projects that enforce commit quality gates.

• blueprint

  Render polished, validated architecture, workflow, sequence, data-flow, and lifecycle/state diagrams as explorable standalone HTML with inline SVG, dark/light themes, optional trace motion, and PNG/JPEG/WebP/SVG/WebM export. blueprint is the renderer behind `ddd export blueprint --deliver` (the fina

• brainstorm

  Use when creating or developing, before writing code or implementation plans - refines rough ideas into fully-formed designs through collaborative questioning, alternative exploration, and incremental validation

• breakdown

  Break down designs into SLC implementation phases with individual plan documents

• change-description

  Generate the description for a change (a merge request on GitLab, a pull request on GitHub) from the story ticket and git changes using a standard template

• changelog-generator

  Produce consistent, auditable release notes from Conventional Commits. Separates commit parsing, semantic-bump logic, and changelog rendering for automated releases with editorial control. Use when cutting a release, generating CHANGELOG.md from git history, computing the next semantic version from

• chaos-engineering

  Use when planning, running, or learning from chaos engineering experiments. Triggers on "chaos experiment", "fault injection", "gameday", "resilience test", "blast radius", "steady state", "abort criteria", "Chaos Toolkit", "Chaos Mesh", "Litmus", "Gremlin", "AWS FIS", or any deliberate failure-inje

• check-implementation

  Use after executing an implementation plan (software:execute-plan or software:swarm) to verify the code matches the plan by checking components, tests, build and UI gates. Its full post-flight mode also verifies the code against the original codebase for wiring completeness (every dependency resolve

• click-path-audit

  Trace every user-facing button/touchpoint through its full state change sequence to find bugs where functions individually work but cancel each other out, produce wrong final state, or leave the UI in an inconsistent state. Use when: systematic debugging found no bugs but users report broken buttons

• code-review-excellence

  Master effective code review practices to provide constructive feedback, catch bugs early, and foster knowledge sharing while maintaining team morale. Use when reviewing pull requests, establishing review standards, or mentoring developers.

• code-sweep

  Multi-perspective code review of a branch, commit, staged set or change. Full mode dispatches 12 specialized reviewers in parallel, each on a single concern, and synthesizes a severity-ranked report with PASS/WARN/FAIL verdicts. Light mode is a single-pass review that reads the commit history and di

• code-to-prd

  Reverse-engineer any codebase into a complete Product Requirements Document (PRD). Analyzes routes, components, state management, API integrations, and user interactions to produce business-readable documentation detailed enough for engineers or AI agents to fully reconstruct every page and endpoint

• code-tour

  Create CodeTour `.tour` files — persona-targeted, step-by-step walkthroughs with real file and line anchors. Use for onboarding tours, architecture walkthroughs, PR tours, RCA tours, and structured "explain how this works" requests. Use when the user asks for a code tour, onboarding walkthrough, PR

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

• complexity-sweep

  Sweep TypeScript/JavaScript, Python, Rust and GDScript (Godot 4) files for over-complex functions: run the bundled static-analysis CLI, flag functions that exceed complexity thresholds (14 metrics across control flow, data flow, cognitive load, information density and composite), review the flagged

• constraint-driven-development

  Establishes a project's quality bar as a written contract and stops agents quietly lowering it. Interviews the user on which dimensions matter, supplies sane default thresholds when they have no number in mind, records everything in CONSTRAINTS.md, and watches the diff for a weakened bar — new @ts-i

• contract-first

  Coordinate frontend/backend or service-to-service work through one authoritative machine-checkable contract (OpenAPI, AsyncAPI, Protocol Buffers, or JSON Schema), with generated consumer types and contract-verified integration. Use when parallel consumer and provider work must evolve an API or event

• control-cli

  Build or adapt a local harness to drive, inspect, and profile an interactive CLI or TUI without external services. Use for CLI UX checks, startup regressions, memory leaks, hangs, prompt flows, or terminal demos.

• control-ui

  Build or adapt a local browser/CDP harness to drive and inspect a web, IDE, or Electron UI, or script a local web app with Python Playwright using a helper that starts and stops its dev servers. Use for local UI verification, testing a local web app, screenshots, accessibility snapshots, browser con

• core

  Prime a codebase once, then stay primed for free. Builds a deterministic zero-token code knowledge graph with graphify, hands the AGENTS.md instruction tree to software:keys, and reads only what those two layers cannot already answer. A quick mode reads the key files for the project type with no gra

• correct

  Find the mistakes agents keep repeating in this repo and make each one impossible. Try architecture first, then types, then a lint whose error names the fix, then a test, and write docs last. Prove each check fails on a real past mistake. Repeat this each time the operator corrects you. Use for /cor

• create-plan

  Use when design is complete and you need detailed implementation tasks for engineers with zero codebase context - creates comprehensive implementation plans with exact file paths, complete code examples, and verification steps

• create-verification-skill

  Generate a project-local verification skill that drives your app the way a user does — any language, framework, or platform. Use for /create-verification-skill, \"make a control skill for this repo\", or when a project has no scripted way to prove UI/CLI/service behavior.

• data

  Relational data rules: Supabase's Postgres performance and best practices (queries, schema, configuration), PostgreSQL table design (data types, indexing, constraints, advanced features), Prisma ORM patterns and traps for TypeScript backends, and safe, reversible database migrations (expand-contract

• ddd-code

  Use when the user wants tactical DDD for a designed system: aggregates and an Aggregate Design Canvas, entities / value objects / invariants, repositories and ports, hexagonal (ports and adapters) architecture for a bounded context, a domain-model implementation, 'turn the design into code structure

• ddd-connect

  Use when the user asks how bounded contexts, modules or services should talk to each other — message flows, "how do the contexts/services communicate", integration between bounded contexts, sequence diagrams across services, sync vs async, events vs API calls, domain message flow modelling, publishe

• ddd-contracts

  Use when the user wants data contracts or message contracts for a designed system: a payload schema for an event, an event/message schema, 'what exactly does this event carry', 'publish a schema for this event', API or event contracts between services, contract-testing inputs, OpenMetadata-style dat

• ddd-decompose

  Step 3 of the 9-step DDD Starter Modelling Process chain (ddd-understand → ddd-discover → ddd-decompose → ddd-strategize → ddd-connect → ddd-organise → ddd-define → ddd-code → ddd-contracts; run ddd for the whole process). Use when the user asks how to break a system up, where to draw the lines, how

• ddd-define

  Step 7 of the 9-step DDD Starter Modelling Process chain (ddd-understand → ddd-discover → ddd-decompose → ddd-strategize → ddd-connect → ddd-organise → ddd-define → ddd-code → ddd-contracts; run ddd for the whole process). Use when the user wants a Bounded Context Canvas, asks to "define the context

• ddd-discover

  Step 2 of the DDD Starter Modelling Process chain (ddd-understand → ddd-discover →

• ddd-organise

  Use when the user asks which team should own which bounded context, how many services or deployable units to build, whether something "should be its own service", modular monolith vs microservices, deployment topology, Team Topologies (stream-aligned / platform / enabling / complicated-subsystem tea

• ddd-strategize

  Use when the user asks which parts of the system are core vs supporting vs generic, wants a core domain chart, asks "where should we invest", "what's our differentiator", "should we build or buy X", "which parts deserve a rich domain model / aggregates / event sourcing", wants an implementation patt

• ddd-understand

  Use when starting domain-driven design on a system — the user wants to "design this system properly", kick off domain modelling or a DDD workflow, asks why the system exists and for whom, wants a Business Model Canvas, Impact Map, product goals with metrics, business capabilities, constraints or a s

• ddd

  Use when the user wants to design a system with Domain-Driven Design end-to-end, asks "where are we in the DDD process", "what's the next DDD step", "ddd status", "run the whole DDD modelling process", "design this system properly before we build it", wants to apply DDD to a new system (anything fro

• debug

  Use when encountering any bug, test failure, or unexpected behavior, before proposing fixes. Also use when the user says "diagnose" or "debug this", or reports something broken, throwing, failing or slow; a diagnosis-loop mode handles hard bugs and performance regressions.

• deepwiki

  Generate, validate and maintain wiki-style documentation for any codebase, with line-level source citations and validated Mermaid diagrams, or write one brownfield architecture document that tells AI agents how an existing system really works. Use when documenting a new project, updating docs after

• dependabot-review

  Review and manage Dependabot PRs. Categorizes by risk, checks CI status, auto-merges safe updates, and reports issues. Use when the user says "review dependabot", "merge dependabot", "dependabot PRs", or "update dependencies".

• dependency-updater

  Smart dependency management for any language. Auto-detects project type, applies safe updates automatically, prompts for major versions, diagnoses and fixes dependency issues.

• deployment-pipeline-design

  Design multi-stage CI/CD pipelines with approval gates, security checks, and deployment orchestration. Use this skill when designing zero-downtime deployment pipelines, implementing canary rollout strategies, setting up multi-environment promotion workflows, or debugging failed deployment gates in C

• deprecation-and-migration

  Manages deprecation and migration. Use when removing old systems, APIs, or features. Use when migrating users from one implementation to another. Use when migrating a database schema in production, such as renaming or dropping a column without downtime (expand/contract). Use when deciding whether to

• devil

  Reviews a product document (PRD, spec, design brief) BEFORE implementation to surface holes - undefined edge cases, missing states, policy gaps - by attacking what the document is SILENT about (unwritten, or written only for the happy path). Acts as a strict sign-off manager, ruling Approve / Condit

• docker-development

  Docker and container development agent skill and plugin for Dockerfile optimization, docker-compose orchestration, multi-stage builds, and container security hardening. Use when: user wants to optimize a Dockerfile, create or improve docker-compose configurations, implement multi-stage builds, audit

• documentation-criteria

  Determines which of PRD, ADR, UI Spec, Design Doc, and Work Plan a change requires, and where each is stored. Use when deciding documentation scope, or when creating or reviewing a technical document.

• dogfood

  Use when asked to dogfood, QA, exploratory test, find issues, bug hunt, or review the quality of a web application. Produces a structured report with full reproduction evidence (screenshots, repro steps) so findings can be handed directly to responsible teams.

• domain-modeling

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

• dotnet-backend-patterns

  Master C#/.NET backend development patterns for building robust APIs, MCP servers, and enterprise applications. Covers async/await, dependency injection, Entity Framework Core, Dapper, configuration, caching, and testing with xUnit. Use when developing .NET backends, reviewing C# code, or designing

• doubt-driven-development

  Subjects every non-trivial decision to a fresh-context adversarial review before it stands. Use when you want every assumption cross-examined before proceeding, when stress-testing a plan for hidden failure modes, when correctness matters more than speed, when working in unfamiliar code, when stakes

• drawio

  Create and edit draw.io/diagrams.net diagrams as editable `.drawio` files. Covers architecture, UML/ERD/sequence, BPMN, network, and swimlane views authored from a description or converted from code, IaC, SQL, and API schemas, plus sync, query, test, review, export, and publish of existing diagrams.

• e2e-harness

  Set up, discover, build, and run end-to-end tests across a whole polyglot system — services in Node, Python, Go, C#, or Rust plus Kafka, Event Hubs, blob storage, S3, Postgres, and cloud emulators — using the deterministic `e2e` CLI in this skill's scripts/ directory. Use this skill whenever the use

• engineering-rules

  Establish SLC engineering ethos and coding standards for collaborative development

• error-handling-patterns

  Master error handling patterns across languages including exceptions, Result types, error propagation, and graceful degradation to build resilient applications. Use when implementing error handling, designing APIs, or improving application reliability.

• execute-plan

  Use when given a complete implementation plan to execute - supports batch execution with review checkpoints, parallel sub-agent dispatch for independent tasks, and resume from checkmarks

• explain-diff

  Use when the user asks for a rich explanation of a code change, diff, branch, or PR. Produces a self-contained HTML explainer with an interactive quiz and Blueprint diagrams for architecture, sequences, data flow, and schema relationships.

• feature-flags-architect

  Use when adding, retiring, or auditing feature flags. Triggers on "add a flag", "ship behind a flag", "rollout plan", "kill switch", "stale flags", "flag debt", "LaunchDarkly", "GrowthBook", "Statsig", "Unleash", "Flipt", or any progressive-delivery question. Ships flag debt scanner, rollout planner

• finishing-a-development-branch

  Use when implementation is complete, all tests pass, and you need to decide how to integrate the work

• full-page-screenshot

  Use when the user asks to capture a full-page screenshot, long screenshot, or complete page capture of a web page. Handles SPA scroll containers, lazy-loaded images, and very tall pages via Chrome DevTools Protocol with zero external dependencies.

• git-advanced-workflows

  Master advanced Git workflows including rebasing, cherry-picking, bisect, worktrees, and reflog to maintain clean history and recover from any situation. Use when managing complex Git histories, collaborating on feature branches, or troubleshooting repository issues.

• git-guardrails-claude-code

  Set up Claude Code hooks to block dangerous git commands (push, reset --hard, clean, branch -D, etc.) before they execute. Use when user wants to prevent destructive git operations, add git safety hooks, or block git push/reset in Claude Code.

• github-actions-creator
• grilling
• human-gate
• improve-codebase-architecture
• improve
• integration-e2e-testing
• interview-me
• ios-simulator
• k6-load-testing
• karpathy-coder
• keys
• kubernetes-patterns
• maintain-verification-skill
• make-pr-easy-to-review
• mcp-dependency-review
• migration-architect
• observability-and-instrumentation
• oh-my-issues
• performance-optimization
• persona
• playwright-pro
• ponytail
• postmortem-writing
• pre-flight
• principles
• product-brainstorming
• prototype
• python-anti-patterns
• react-testing
• react-typescript
• receiving-code-review
• requirement-convergence
• research-codebase
• retro
• rules-from-code
• saga-orchestration
• santa-method
• security-and-hardening
• security-best-practices
• security-sweep
• security-threat-model
• ship-gate
• show-me-your-work
• skill-security-auditor
• slo-architect
• source-driven-development
• spec-driven-workflow
• spec
• stow
• swarm
• systems
• tdd
• terraform-patterns
• test-audit
• trace
• ui-demo
• unlazy
• using-git-worktrees
• verification-before-completion
• verify-feature
• verify-this
• web-quality-audit
• whats-next
• why
• windows-desktop-e2e
• wizard
• workflow

Subagents (5)

• code-reviewer

  Expert code review specialist. Proactively reviews code for quality, security, and maintainability. Use immediately after writing or modifying code.

• codebase-analyzer

  Analyzes codebase implementation details. Call the codebase-analyzer agent when you need to find detailed information about specific components. As always, the more detailed your request prompt, the better! :)

• codebase-locator

  Locates files, directories, and components relevant to a feature or task. Call `codebase-locator` with human language prompt describing what you're looking for. Basically a "Super Grep/Glob/LS tool" - Use it if you find yourself desiring to use one of these tools more than once.

• codebase-pattern-finder

  codebase-pattern-finder is a useful subagent_type for finding similar implementations, usage examples, or existing patterns that can be modeled after. It will give you concrete code examples based on what you're looking for! It's sorta like codebase-locator, but it will not only tell you the locatio

• ddd-decision-strategist

  Unbiased decision strategist for the ddd-* skill chain. Use whenever a design decision has to be deduced, figured out, or argued rather than read off an artifact - where to draw a boundary, whether two contexts merge, core vs supporting, build vs buy, how many deployables, sync vs async, which conte

Similar plugins