jm-adk

Create or update a CONSTITUTION.md that defines project governance — establishes coding standards, quality gates, TDD policy, review requirements, and non-negotiable development principles with versioned amendment tracking. Use when defining project rules, setting up coding standards, establishing quality gates, configuring TDD requirements, or creating non-negotiable development principles.

Create a feature specification from a natural language description — generates user stories with Given/When/Then scenarios, functional requirements (FR-XXX), success criteria, and a quality checklist. Use when starting a new feature, writing a PRD, defining user stories, capturing acceptance criteria, or documenting requirements for a product idea.

Generate Gherkin .feature files from requirements before implementation — produces executable BDD scenarios with traceability tags, computes assertion integrity hashes, and locks acceptance criteria for test-driven development. Use when writing tests first, doing TDD, creating test cases from a spec, locking acceptance criteria, or setting up red-green-refactor with hash-verified assertions.

Validate cross-artifact consistency — checks that every spec requirement traces to tasks, plan tech stack matches task file paths, and constitution principles are satisfied across all artifacts. Use when running a consistency check, verifying requirements traceability, detecting conflicts between design docs, or auditing alignment before implementation begins.

Generate a technical design document from a feature spec — selects frameworks, defines data models, produces API contracts, and creates a dependency-ordered implementation strategy. Use when planning how to build a feature, writing a technical design doc, choosing libraries, defining database schemas, or setting up Tessl tiles for runtime library knowledge.

Generate quality checklists that validate requirements completeness, clarity, and consistency — produces scored checklist items linked to specific spec sections (FR-XXX, SC-XXX). Use when reviewing a spec for gaps, doing a requirements review, verifying PRD quality, auditing user stories and acceptance criteria, or gating before implementation.

Generate dependency-ordered task breakdown from plan and specification. Use when breaking features into implementable tasks, planning sprints, or creating work items with parallel markers.

Execute the implementation plan by coding each task from tasks.md — writes source files, runs tests, verifies assertion integrity, and validates output against constitutional principles. Use when ready to build the feature, start coding, develop from the task list, or resume a partially completed implementation.

Convert tasks from tasks.md into GitHub Issues with labels and dependencies. Use when exporting work items to GitHub, setting up project boards, or assigning tasks to team members.

Report a bug against an existing feature — creates a structured bugs.md record, generates fix tasks in tasks.md, and optionally imports from or creates GitHub issues. Use when fixing a bug, reporting a defect, importing a GitHub issue into the workflow, or triaging an error without running the full specification process.

Resolve ambiguities in any project artifact — auto-detects the most recent artifact (spec, plan, checklist, testify, tasks, or constitution), asks targeted questions with option tables, and writes answers back into the artifact's Clarifications section. Use when requirements are unclear, a plan has trade-off gaps, checklist thresholds feel wrong, test scenarios are imprecise, task dependencies seem off, or constitution principles are vague.

Initialize an IIKit project, check feature progress, select the active feature, and display the workflow command reference. Use when starting a new project, running init, checking status, switching between features, or looking up available commands and phases.

Audits all SKILL.md files in a plugin against a 6-criteria excellence rubric, producing per-skill scores, plugin averages, and actionable improvement recommendations. Trigger: audit content quality, score skills, check skill quality, content rubric.

Performs a comprehensive security audit on a Claude Code plugin, detecting leaked secrets, unsafe paths, shell injection risks, sensitive files, and insecure scripts. Trigger: audit security, security scan, check for secrets, find vulnerabilities.

Create MOAT directory structures and populate asset files (references/, examples/, prompts/, scripts/, assets/) for plugin skills. Trigger: build MOAT assets, create skill assets, populate references, generate examples, build skill directories.

Scaffold a complete plugin directory from architecture plans and specs. Creates all files, then validates structure. Trigger: build plugin, scaffold plugin, create plugin directory, assemble plugin, generate plugin files.

Design a plugin agent: role, tool allowlist, skill assignments, execution flows, operating principles. Trigger: design agent, agent design, create agent spec, plan agent, draft agent. Enforces plugin subagent constraints (no hooks/mcpServers/permissionMode in frontmatter).

Design a plugin skill in detail: frontmatter, procedure outline, quality criteria, anti-patterns, edge cases, tool selection. Trigger: design skill, skill design, create skill spec, plan skill, draft skill.

Automatically fixes mechanical issues found during plugin validation, including JSON formatting, missing shebangs, file permissions, hook types, frontmatter gaps, and settings.json defaults. ALWAYS asks for confirmation before modifying any files. Trigger: fix issues, auto-fix, fix common problems, repair plugin.

Generates a comprehensive QA report in Markdown combining findings from all validation and audit skills, with executive summary, categorized findings, and prioritized recommendations. Trigger: generate QA report, full report, plugin report, qa summary.

Produces a compact executive scorecard grading a plugin across 7 quality dimensions with a letter grade, numeric score, and top 3 priority actions. Trigger: generate scorecard, qa scorecard, plugin grade, executive summary.

Brainstorm individual plugin components (skill, agent, command, hook) for existing or planned plugins. Trigger: ideate component, brainstorm skill, new agent idea, component concept, add skill to plugin.

Generate a structured plugin concept brief from a user idea. Trigger: ideate plugin, brainstorm plugin, plugin concept, new plugin idea, create plugin concept. Researches existing plugins for overlap, proposes movement structure and component counts.

Generate plugin architecture plan with agent roles, skill-movement mapping, hook strategy, and command routing. Trigger: plan architecture, design plugin structure, architect plugin, plugin architecture, plan plugin layout.

Design MOAT asset strategy per skill: which subdirectories needed, what content they contain, naming conventions. Trigger: plan MOAT, MOAT strategy, asset planning, reference planning, plan skill assets.

Generate production-ready agent .md and command .md files from designs. Enforces plugin subagent constraints and alias linkage. Trigger: spec agent, spec command, generate agent file, write command file, create agent specification.

Generate production-ready SKILL.md and MOAT asset files from a skill design. Enforces MOAT quality dimensions (>=7 on all 6), 500-line body limit, progressive disclosure. Trigger: spec skill, generate skill spec, write SKILL.md, create skill specification, produce skill MOAT.

Validates frontmatter and body structure of all skills, agents, and commands in a plugin. Triggers: validate components, check frontmatter, component audit, skill validation.

Validates cross-reference integrity across all plugin components. Detects broken references, orphaned skills, missing aliases, and settings.json inconsistencies. Triggers: validate cross-refs, check references, dependency audit, orphan detection.

THE CRITICAL SKILL -- validates hooks.json structure, event names, and type-event compatibility. Detects prompt/agent hooks on events lacking ToolUseContext. Triggers: validate hooks, check hooks.json, hooks audit, hook safety check.

Validates plugin.json completeness, field correctness, and consistency with actual plugin contents. Triggers: validate manifest, check plugin.json, manifest audit.

Validates plugin directory layout against the official Claude Code plugin spec. Triggers: validate structure, check layout, directory audit, plugin skeleton check.

Writes testable acceptance criteria in Given/When/Then format, covering happy paths, edge cases, and error scenarios. Trigger: "acceptance criteria", "given when then", "write AC", "define done", "user story criteria".

Implement WCAG 2.1 AA / 2.2 accessibility: semantic HTML audit, ARIA implementation, keyboard navigation, screen reader testing, color contrast. Use when user asks to "implement accessibility", "fix a11y issues", "make WCAG compliant", or "audit for accessibility".

Produces Architecture Decision Records following the Nygard/MADR template with full context, consequences, and traceability. Trigger: "generate ADR", "document decision", "architecture decision record", "record this decision".

dbt-style transformations, dimensional data modeling, testing strategies, and documentation generation for analytics platforms. Trigger: "analytics engineering", "dbt", "data modeling", "dimensional model", "star schema", "data marts".

REST, GraphQL, and gRPC API governance, versioning strategy, rate limiting, and developer experience design. Trigger: "API architecture", "API design", "REST", "GraphQL", "gRPC", "API governance", "developer experience".

Contract-first API design producing OpenAPI specs, GraphQL schemas, or protobuf definitions with versioning strategy. Trigger: "design API", "OpenAPI spec", "GraphQL schema", "protobuf definition", "API contract".

REST, GraphQL, and gRPC contract analysis including versioning, consistency, and completeness. Trigger: "analyze API", "API surface", "endpoint audit", "contract analysis".

Architecture proposals with trade-off analysis, alternatives matrix, and decision rationale. Trigger: design architecture, propose solution, evaluate alternatives, create ADR.