dev

Plugin dev from marketplace magus in MadAppGang/magus. Commands read from the repo's manifest — today.

Skills (19)

• architecture

  Router for architecture knowledge — 7 architectural styles (layered, hexagonal, clean, modular monolith, microservices, event-driven, CQRS) and the 22 GoF design patterns. Names which file to read; loads none of them.

• db-branching

  Branches Neon, Turso, or Supabase per git worktree for isolated schema work. Use when a worktree changes the schema, or on mention of Neon, Turso, Prisma.

• code-roast

  Roasts code with severity-graded sins, cites file and line, offers redemption. Use when the user asks to roast code, find sins, or shame my code.

• context-detection

  Detects the project stack from its config files, then names the one or two dev skill files to read for this task — it loads none of them. Use at the start of any coding task, or on an unfamiliar or multi-stack repo.

• aggregate-reviews

  Merges independent reviews of one target into one report with a consensus tag per finding and a verdict from supplied thresholds; also synthesises research findings. Use when several reviews or votes must become one file a gate reads.

• team-gate

  Runs a multi-model review gate to a verdict: start the claudish team panel with input_file only, poll until settled, read every ballot, apply the minimum ballot count, log every skip. Use at any plan-review, code-review, verify or fix gate.

• testing-strategies

  Testing pyramid, AAA structure, test doubles, fixtures, assertions and coverage targets, in any language. Use when writing, reviewing or setting up tests. Do not use for the write-test-first loop — that is test-driven-development.

• universal-patterns

  Code organization, error handling, data flow, naming and anti-patterns in any language. Use while writing or reviewing everyday code. Do not use to choose a system shape or a design pattern — read the architecture skill instead.

• systematic-debugging

  Root-cause debugging — reproduce, localize, explain, verify — with depth routing and a technique catalogue for stack traces, wolf fence and data-flow tracing. Use when anything errors, crashes or misbehaves, even on a bare pasted trace.

• test-driven-development

  RED-GREEN-REFACTOR: write a failing test, watch it fail, make it pass, refactor. Use before writing any production code or bug fix, or on mention of TDD or test-first, even if the user asked only for the implementation.

• verification-before-completion

  Requires fresh evidence — command output, a test run, a screenshot — before any completion claim. Use when marking work done, saying something is fixed, or before committing, even when the change looks obviously correct.

• worktree-lifecycle

  Creates, uses and cleans up git worktrees with safety checks. Use before isolated, risky or parallel feature work, or on mention of worktree, experiment or prototype.

• documentation-standards

  15 ranked documentation practices, 7 templates and anti-slop writing rules. Use when writing or reviewing a README, API reference, guide or changelog, even if the user only says \"document this\".

• browser-debugging

  Drives a real browser — claude-in-chrome or browser-use — to verify a UI change, read console and network activity, and reproduce browser-only bugs. Use when checking UI in a running app or chasing a console error.

• design-system-guardrails

  Enforces single-source-of-truth UI — design tokens for every style value, one component library, variants instead of call-site restyling. Use before writing or reviewing any component, screen, theme or style, even a one-line tweak.

• frontend-implement

  Rewrites generic-looking UI into a deliberate design via theme tokens and library variants, never call-site values. Use when applying design-review fixes, or when a UI looks AI-generated.

• brainstorming

  Explores solution approaches in parallel across models through claudish, then has an external panel review the chosen plan. Use when the direction is open, or the user asks to brainstorm or compare approaches.

• plugin-sdk-patterns

  Builds Claude Code plugins that load — manifest location, what registers, the frontmatter each component reads, hooks, MCP servers, verification. Use when creating or editing a plugin or its parts.

• ui-playwright

  Writes Playwright UI tests — role locators, page objects, fixtures, network stubs, snapshot policy, one test per Storybook story state. Use when testing a screen, component, or user flow in a browser.

Slash commands (17)

• /dev:architect

  Architecture design and technical planning — complexity-aware with plan mode reasoning and multi-model escalation

• /dev:audit

  Structured quality audit — routes to specialist reviewers for code, UI, docs, security, or plugin quality

• /dev:debug

  Structured debugging — routes to quick patch (inline), standard debug (skill), or production-grade fix (/dev:fix)

• /dev:design-system

  Validate a project against the design-system guardrails — token-only styling, one component library, variants over call-site restyling. Reports drift by rule, and can fix it or scaffold the guardrails.

• /dev:dev

  Builds a feature through an 8-phase workflow, delegating each phase to a specialist agent. Depth picks how many phases run, automation how often it stops to ask.

• /dev:doc

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

• /dev:fix

  Fixes a bug test-first — reproduce, localize, plan, patch, validate. Two multimodel gates, one on the root-cause hypothesis before any code and one on the finished patch.

• /dev:help

  Show dev plugin help, detected stack, and available commands

• /dev:interview

  Comprehensive specification interview with intelligent requirements elicitation

• /dev:investigate

  Read-only code investigation — architecture traces, implementation analysis, bug origin tracking with specialist agents

• /dev:learn

  Analyze session for learnable patterns, apply pending learnings (--apply), or prune stale preferences (--prune)

• /dev:qa

  Writes behaviour tests from a spec and a public contract with a writer that never sees the implementation — the top-tier model of the first non-Claude family that answers via claudish (GPT, then Gemini, then another), asking when none does — then runs them and a negative control.

• /dev:release

  Releases the current project through a phased pipeline — preflight gates, version+changelog PR, merge, tag, publish, verify against the public registry. Detects and drives the project's own release tooling; resumable after partial failure.

• /dev:research

  Multi-source research with convergence-based finalization and parallel exploration

• /dev:setup

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

• /dev:status

  Reconstructs where this session stands — the original idea, decisions, plan changes, done-and-verified vs unverified vs not done, blockers, git and PR truth — and whether the worktree can be removed. Use after a compaction or resume, or before deleting a worktree.

• /dev:worktree

  Manage git worktrees - create isolated workspaces, list active worktrees, and clean up. Supports automatic Neon DB branching for schema isolation.

Subagents (12)

• aggregator

  Merges several reviews of one target into the one report a gate reads, tagging each finding with its consensus and computing the verdict from the thresholds it is handed; also synthesises research findings across iterations. Hand over `REVIEWS:` (one path per line), `THRESHOLDS:` quoted verbatim and

• architect

  Plans system architecture in any language, weighing trade-offs and naming what each choice costs. Use before building a new system or subsystem, for a major refactor, or when comparing two designs. Hand over the requirements and constraints, the paths of any existing code the design must fit, and wh

• debugger

  Traces an error to its root cause across files, in any language, and reports the evidence for the diagnosis. Use when a bug is not obvious from the stack trace, or when a failure spans several modules. Supply the exact error text or stack trace and the reproducing command or steps; explicitly say if

• developer

  Implements features spanning multiple files, then iterates write-test-fix-lint until every check passes. Use for new modules, subsystems, or any change needing 3+ files with test coverage. Hand over the files or directories to create or modify, the skill files it must read first (project skills befo

• devops

  Handles infrastructure work — CI pipelines, containers, deploys, observability — and reasons through the trade-offs before anything is applied — it produces the commands and IaC, it does not run them against live infrastructure. Use when setting up or debugging a pipeline, a deploy, or a runtime env

• docs

  Writes, analyses, and fixes documentation. Pass mode=write|analyze|fix, the exact doc paths to work on and the source paths that ground them, and SESSION_PATH so analyze and fix share one report — fix mode needs the analysis report path and which findings are approved, and applies nothing else. Use

• frontend-developer

  Builds and revises React components against the project's design system — library components with Storybook stories, tokens only, screens compose. Use when implementing or reworking UI. Hand over the component path, theme and library locations, SESSION_PATH if any, and screenshot paths if any.

• qa-engineer

  Writes behaviour tests from a spec and a public contract without reading the implementation — Go, Bun/TypeScript, UI via Playwright. Use when coverage must check the spec, not the code. Hand over SPEC_PATH, CONTRACT_PATHS, TEST_DIR, the stack, and STOP_AT (plan, implement, run, analyse).

• researcher

  Multi-round web research with convergence detection — searches 10+ sources, assesses their quality, and returns a cited report. Use for technology evaluations, library comparisons, and best-practice surveys. Supply the decision the research feeds (e.g. choosing a library that must work offline), the

• reviewer

  Reviews recent changes in three passes — security, correctness, maintainability — plus a design-system pass on UI files, returning severity-calibrated findings and a PASS/CONDITIONAL/FAIL verdict. Give it a TARGET: line — exact file paths (FILES mode), a capture file (CAPTURE mode), or BRANCH — plus

• spec-writer

  Synthesizes a specification from an interview session, reading the log, assets and context to produce spec.md and tasks.md. Callers must hand over the SESSION_PATH directory holding interview-log.md, assets.md and context.json. Use when an interview has finished and its answers need turning into a b

• stack-detector

  Classifies a repo's stacks and quality commands, resolves what the task is, inventories reachable MCP servers, and writes a per-agent reading list to context.json. Requires the `SESSION_PATH` to write into, the task as a `TASK:` block (or requirements.md / bug-report.md in that directory), and wheth

Hooks (9)

• Stop

  ${CLAUDE_PLUGIN_ROOT}/hooks/stop-coaching.sh

• Stop

  bun --env-file=/dev/null ${CLAUDE_PLUGIN_ROOT}/hooks/phase-completion-validator.ts --stop

• SessionStart

  ${CLAUDE_PLUGIN_ROOT}/hooks/session-start-coaching.sh

• SessionStart

  bun --env-file=/dev/null --config=/dev/null ${CLAUDE_PLUGIN_ROOT}/hooks/magus-version-check.ts

• SessionStart

  command -v bun >/dev/null 2>&1 && exec bun --env-file=/dev/null --config=/dev/null "${CLAUDE_PLUGIN_ROOT}/hooks/deps-check.ts" dev || exec sh "${CLAUDE_PLUGIN_ROOT}/hooks/bun-missing.sh" dev

• SessionStart

  bun --env-file=/dev/null ${CLAUDE_PLUGIN_ROOT}/hooks/status-reinject.ts

• SessionStart

  bun --env-file=/dev/null ${CLAUDE_PLUGIN_ROOT}/hooks/resume-after-clear.ts

• UserPromptSubmit

  bun --env-file=/dev/null ${CLAUDE_PLUGIN_ROOT}/hooks/plan-mode-protocol.ts

• PostToolUse

  bun --env-file=/dev/null ${CLAUDE_PLUGIN_ROOT}/hooks/resume-after-plan.ts

Similar plugins