dev

Plugin dev from marketplace mag-claude-plugins in MadAppGang/claude-code. Commands read from the repo's manifest — 1 month ago.

Skills (47)

• adr-documentation

  Architecture Decision Records (ADR) documentation practice. Use when documenting architectural decisions, recording technical trade-offs, creating decision logs, or establishing architectural patterns. Trigger keywords - "ADR", "architecture decision", "decision record", "trade-offs", "architectural

• audit

  On-demand security and code quality audit. Use when checking for vulnerabilities, security issues, code smells, or compliance problems. Trigger keywords - "audit", "security check", "vulnerability scan", "code quality", "compliance", "security audit".

• api-design

  Use when designing REST or GraphQL APIs, defining endpoints, implementing pagination/filtering, handling API versioning, or establishing API documentation with OpenAPI/Swagger.

• auth-patterns

  Use when implementing authentication (JWT, sessions, OAuth), authorization (RBAC, ABAC), password hashing, MFA, or security best practices for backend services.

• bunjs-apidog

  Use when creating OpenAPI specs for Bun.js APIs, integrating with Apidog, documenting endpoints with schemas, or automating API specification imports via Apidog REST API. See bunjs for basics.

• bunjs-architecture

  Use when implementing clean architecture (routes/controllers/services/repositories), establishing camelCase conventions, designing Prisma schemas, or planning structured workflows for Bun.js applications. See bunjs for basics, bunjs-production for deployment.

• bunjs-production

  Use when deploying Bun.js to production, containerizing with Docker, setting up AWS ECS/Fargate, implementing Redis caching, hardening security, or configuring CI/CD pipelines. See bunjs for basics, bunjs-architecture for patterns.

• bunjs

  Use when building Bun.js/Hono applications, implementing HTTP endpoints, setting up Prisma/SQLite, writing Zod validation, or using Bun's test runner. See bunjs-architecture for layered patterns, bunjs-production for deployment.

• database-patterns

  Use when designing database schemas, implementing repository patterns, writing optimized queries, managing migrations, or working with indexes and transactions for SQL/NoSQL databases.

• dingo

  Use when working with Dingo meta-language for Go, implementing optionals/results, using generics shortcuts, or transpiling .dingo files to .go while maintaining Go compatibility.

• error-handling

  Use when implementing custom error classes, error middleware, structured logging, retry logic, or graceful shutdown patterns in backend applications.

• golang-performance

  Use when profiling Go applications (pprof), running benchmarks, optimizing memory/CPU usage, or debugging performance bottlenecks in production Go code.

• golang

  Use when building Go backend services, implementing goroutines/channels, handling errors idiomatically, writing tests with testify, or following Go best practices for APIs/CLI tools.

• python

  Use when building FastAPI applications, implementing async endpoints, setting up Pydantic schemas, working with SQLAlchemy, or writing pytest tests for Python backend services.

• rust

  Use when building Axum applications, implementing type-safe handlers, working with SQLx, setting up error handling with thiserror, or writing Rust backend services.

• context-detection

  Use when detecting project technology stack from files/configs/directory structure, auto-loading framework-specific skills, or analyzing multi-stack fullstack projects (e.g., React + Go).

• debugging-strategies

  Use when troubleshooting bugs, analyzing stack traces, using debugging tools (breakpoints, loggers), or applying systematic debugging methodology across any technology stack.

• testing-strategies

  Use when writing tests, setting up test frameworks, implementing mocking strategies, or establishing testing best practices (unit, integration, E2E) across any technology stack.

• universal-patterns

  Use when implementing language-agnostic patterns like layered architecture, dependency injection, error handling, or code organization principles across any technology stack.

• design-references

  Predefined design system references for UI reviews. Includes Material Design 3, Apple Human Interface Guidelines, Tailwind UI, Ant Design, and Shadcn/ui. Use when conducting design reviews against established design systems.

• ui-analyse

  UI visual analysis patterns using Gemini 3 Pro Preview multimodal capabilities. Analysis-only - no code changes. Use dev:ui-implement for applying improvements. Includes provider detection, prompting patterns, and severity guidelines.

• ui-design-review

  Prompting patterns and review templates for UI design analysis with Gemini multimodal capabilities. Use when conducting design reviews, accessibility audits, or design system validation.

• ui-implement

  Patterns for implementing UI improvements based on design analysis. Works with review documents from dev:ui-analyse or /dev:ui command. Includes Anti-AI design rules and visual verification.

• ui-style-format

  UI design style file format specification with reference image support. Defines the schema for .claude/design-style.md and .claude/design-references/. Use when creating, validating, or parsing project design styles.

• agent-coordination-discipline

  Use when deciding whether to launch an agent, selecting which agent to use, or coordinating multiple agents. Covers delegation criteria, external-model patterns, task isolation, and agent selection strategies.

• systematic-debugging

  Use when debugging failures, errors, or unexpected behavior. Covers root cause investigation, data flow tracing, hypothesis-driven debugging, and fix verification to prevent trial-and-error approaches.

• test-driven-development

  Use when writing production code. Enforces RED-GREEN-REFACTOR cycle: write failing test, make it pass, improve design. Prevents test-after development and ensures verified behavior.

• verification-before-completion

  Use when claiming task completion or marking items as done. Covers completion evidence requirements, verification methods, and anti-rationalization patterns.

• worktree-lifecycle

  Use when starting isolated feature work or before executing implementation plans. Manages full worktree lifecycle from creation through cleanup with safety checks and error recovery.

• documentation-standards

  Use when writing README files, API documentation, user guides, or technical documentation following industry standards from Google, Microsoft, and GitLab style guides.

• phase-enforcement

  Evidence-based phase completion enforcement for /dev:feature. Use when orchestrating 8-phase feature development to ensure artifacts exist before phase completion, validation criteria are addressed, outer loops are enforced, and show-your-work requirements are met.

• browser-debugging

  Systematically tests UI functionality, validates design fidelity with AI visual analysis, monitors console output, tracks network requests, and provides debugging reports using Chrome Extension MCP tools. Use after implementing UI features, for design validation, when investigating console errors, f

• css-modules

  CSS Modules with Lightning CSS and PostCSS for component-scoped styling. Covers *.module.css patterns, TypeScript integration, Vite configuration, and composition. Use when building complex animations, styling third-party components, or migrating legacy CSS.

• react-typescript

  Modern React 19+ patterns with TypeScript including function components, hooks, state management, TanStack Query integration, form handling with Zod, error boundaries, and performance optimization. Use when building React applications, implementing components, or setting up state management.

• shadcn-ui

  shadcn/ui component library patterns. Covers CLI usage, installation, component categories, theming with CSS variables, dark mode setup, and integration with React Hook Form + Zod. Use when adding UI components, setting up design systems, or implementing forms with shadcn/ui.

• state-management

  Use when choosing state management solutions, implementing global stores (Zustand, Pinia), managing server state (TanStack Query), or handling URL state in frontend applications across React and Vue.

• tailwindcss

  TailwindCSS v4 patterns with CSS-first configuration using @theme, @source, and modern CSS features. Covers design tokens, CSS variables, container queries, dark mode, and Vite integration. Use when configuring Tailwind, defining design tokens, or leveraging modern CSS with Tailwind utilities.

• tanstack-query

  Comprehensive TanStack Query v5 patterns for async state management. Covers breaking changes, query key factories, data transformation, mutations, optimistic updates, authentication, testing with MSW, and anti-patterns. Use for all server state management, data fetching, and cache invalidation tasks

• tanstack-router

  TanStack Router patterns for type-safe, file-based routing. Covers installation, route configuration, typed params/search, layouts, and navigation. Use when setting up routes, implementing navigation, or configuring route loaders.

• testing-frontend

  Use when writing component tests, testing user interactions, mocking APIs, or setting up Vitest/React Testing Library/Vue Test Utils for frontend applications.

• vue-typescript

  Use when building Vue 3 applications with TypeScript, implementing Composition API components, setting up Pinia stores, or working with Vue Router. Covers script setup, composables, and reactive state.

• mcp-standards

  MCP server standardization patterns for Claude Code plugins. Use when implementing MCP servers, designing tool interfaces, configuring MCP transports, or standardizing MCP naming conventions. Trigger keywords - "MCP", "MCP server", "MCP tools", "MCP transport", "tool naming", "MCP configuration".

• optimize

  On-demand performance and optimization analysis. Use when identifying bottlenecks, improving build times, reducing bundle size, or optimizing code performance. Trigger keywords - "optimize", "performance", "bottleneck", "bundle size", "build time", "speed up".

• brainstorming

  Collaborative ideation and planning with resilient multi-model exploration, consensus scoring, and adaptive confidence-based validation

• plugin-sdk-patterns

  Unified patterns and templates for creating consistent Claude Code plugins. Use when creating new plugins, designing plugin architecture, implementing builder patterns, or standardizing plugin structure. Trigger keywords - "plugin SDK", "plugin template", "plugin pattern", "builder pattern", "plugin

• task-routing

  Use BEFORE delegating any complex task to a subagent. Contains the routing table that maps task patterns to the correct specialized agent. MUST be consulted before using the Task tool for delegation decisions. Trigger keywords - "delegate", "subagent", "agent", "research", "implement", "investigate"

• test-coverage

  On-demand test coverage analysis. Use when identifying untested code, finding test gaps, measuring coverage metrics, or improving test quality. Trigger keywords - "test coverage", "coverage report", "untested code", "test gaps", "missing tests", "coverage metrics".

Slash commands (15)

• /dev:architect

  Universal architecture planning for any stack with trade-off analysis

• /dev:brainstorm

  Collaborative ideation and planning with multi-model exploration and consensus scoring

• /dev:create-style

  Interactive wizard to create and update project design style guides. Supports reference image capture, style updates, and visual reference management. Actions: create, update, capture, add-reference, remove-reference, list-references - dev:design-references - dev:ui-style-format

• /dev:debug

  Universal debugging command that adapts to any technology stack

• /dev:deep-research

  Deep research with convergence-based finalization and parallel exploration

• /dev:delegate

  Route a task to the best specialized agent using the task routing table

• /dev:doc

  Documentation command - generate, analyze, fix, or validate docs. Use for README, API docs, tutorials, changelogs.

• /dev:feature

  8-phase feature development with real validation loops

• /dev:help

  Show dev plugin help, detected stack, and available commands

• /dev:implement

  Universal implementation command with optional real validation

• /dev:interview

  Comprehensive specification interview with intelligent requirements elicitation

• /dev:learn

  Analyze session for learnable patterns and propose CLAUDE.md updates

• /dev:setup

  Set up project CLAUDE.md with task routing table and agent delegation rules

• /dev:ui

  UI design review using Gemini multimodal analysis for usability and accessibility

• /dev:worktree

  Manage git worktrees - create isolated workspaces, list active worktrees, and clean up

Subagents (16)

• architect

  Language-agnostic architecture planning for system design and trade-off analysis

• debugger

  Language-agnostic debugging for error analysis and root cause investigation

• developer

  Use this agent when you need substantial implementation work spanning multiple files with tests and quality validation. The agent runs a complete implementation cycle - write code, run tests, fix failures, run linting, iterate until all checks pass - which requires sustained focus that cannot be mai

• devops

  Infrastructure and DevOps specialist with extended thinking for complex decisions

• doc-analyzer

  Analyze documentation quality using 42-point research-backed checklist. Detects anti-patterns, scores quality, identifies missing sections. Use when: "check doc quality", "analyze README", "audit documentation" - Read - Glob - Grep - Write - dev:documentation-standards

• doc-fixer

  Automatically fix documentation issues and apply transformations. Supports: passive->active voice, add missing sections, restructure for progressive disclosure. Use when: "fix documentation", "improve docs", "update README" - Read - Write - Edit - Bash - Glob - Grep - dev:documentation-standards

• doc-writer

  Generate high-quality documentation following 15 research-backed best practices. Supports: README, API docs (TSDoc/JSDoc), tutorials, changelogs, ADRs, error docs. Use when: "write documentation", "create README", "document function", "add tutorial" - Read - Write - Bash - Glob - Grep - dev:document

• researcher

  Use this agent when you need comprehensive research that requires searching the web across 10+ sources, comparing findings, assessing source quality, and producing structured research reports with citations. The agent runs multiple search rounds with convergence detection - it keeps researching unti

• scribe

  Lightweight file writer for interview sessions. Appends Q&A to interview log, updates checkpoints, and maintains session state. Designed for fast, reliable file operations.

• skill-discovery

  Deep skill cataloging - discovers all Claude Code Agent Skills in a project

• spec-writer

  Synthesizes comprehensive specifications from interview sessions. Reads interview log, assets, and context to produce structured spec.md and tasks.md documents.

• stack-detector

  Analyzes project to detect technology stack and discover real Claude Code skills

• synthesizer

  Research synthesis for consolidating multi-source findings with consensus detection

• test-architect

  Black box test architect that creates tests from requirements only

• ui-engineer

  Avant-garde React component generator with visual analysis capabilities. Uses Gemini 3 Pro Preview for screenshot understanding and design review. Examples: "Improve this component based on review", "Create glassmorphic dashboard matching reference", "Build hero section for creative agency" - TaskCr

• ui

  UI design review, usability analysis, accessibility checks, and Figma implementation help

MCP servers (1)

• claudish

  runs: claudish --mcp

Similar plugins