Spec-Driven-Development-toolkits

Audit a Jira or Azure DevOps board against ways-of-working rules, produce a tagged cleanup plan, then on one confirm gate apply safe bulk fixes and delegate epic/story/subtask creation to sibling skills. Triggers: audit my board, board audit, ado board audit, jira audit, audit board, backlog cleanup, board hygiene, board health, clean up jira, sprint cleanup, iteration cleanup, sprints used as epics, hidden tickets, fix backlog, organize backlog, epic story audit, backlog triage.

Shared board-provider layer — detect whether this session talks to Jira or Azure DevOps (ADO), load the matching provider mapping (tool names, query language, types, states), and record the choice in the calling skill's config.json. Board-facing skills delegate their provider detection here and stay platform-neutral. Triggers: which board provider, board setup, connect jira, connect ado, azure devops setup, board provider.

Author a new Claude Code skill — folder + SKILL.md + frontmatter, lean 50–120 lines, grounded in the host project's real files and conventions, integrated with sibling skills. Triggers: create skill, new skill, add skill, write skill, skill for, author skill, scaffold skill.

Standalone task orchestrator — take a request (or a board ticket) from GO gate through implement → test → verify → review → finalize by delegating to sibling m-skills. Works with or without an SDD spec. Triggers: implement, build, create feature, add feature, new screen, new page, task, scaffold, build X, ship this ticket, work on this ticket, do the ticket.

PM ticket authoring at the right altitude — turn a bug report, feature ask, or an over-technical draft into ONE clean ticket/work item that stops at Problem, Impact, Reproduction, and Acceptance Criteria, stripping engineering diagnosis (root cause, code, file:line, commit hashes, proposed fix) and leaving it to engineering. Works against Jira or Azure DevOps via the m-board provider layer; creates the ticket only after a confirm gate. Triggers: write a ticket, pm ticket, create work item, ado ticket, jira ticket, bug ticket at the right altitude, de-technify this ticket, file a bug, report a bug, raise a ticket, bug report, feature request, my ticket is too technical, clean up this ticket, acceptance criteria, problem impact reproduction, ticket too engineering-heavy.

QA deliverable generator — produce test plans, manual test cases, regression suites, design-vs-implementation validations, and structured bug reports from a feature description, in Markdown ready for any tracker. Optional Figma MCP integration for pixel-level design validation. Triggers: test plan, test cases, regression suite, QA, bug report, figma validation, manual testing, smoke test, test coverage.

Meta audit of a SKILL.md — frontmatter shape, trigger coverage, grounding to real files, compliance with the HOST project's own conventions, integration with sibling skills, length & tone. Triggers: review skill, audit skill, check skill, skill quality, validate skill, skill review.

SDD phase 7 — the SDD adapter around the m-implement engine: gate on tasks+analyze, human GO, then delegate the implement→test→verify→review→finalize loop to m-implement, and record/route the SDD state. Triggers: sdd implement, execute sdd plan, build the feature sdd, run sdd tasks, implement sdd.

Board story/epic orchestrator (Jira or Azure DevOps) — create the parent story or epic if it doesn't exist, assess whether it needs breaking down, and (on confirmation) create per-stack tickets typed Story/Task/Subtask by intent, linked via the board's MCP tools (provider detected via m-board). Triggers: break story, split story, decompose story, story breakdown, create subtasks, create dev tickets, story to tasks, jira breakdown, azure devops, ado, create story, create epic, jira from feature, feature to jira, plan to jira tickets, tasks to work items.

Guides stable API and interface design. Use when designing APIs, module boundaries, or any public interface. Use when creating REST endpoints, defining type contracts between modules, or establishing boundaries between frontend and backend. Examples assume TypeScript/REST. Triggers: new endpoint, API design, REST, pagination, breaking change, interface contract, module boundary, versioning.

Project-grounded advisor: answer any question, brainstorm, compare approaches, or recommend strategy grounded in THIS codebase and its own conventions — not generic advice. Triggers: how do I, what is, should I, why does, explain, brainstorm, compare, best way, recommend, advice, strategy, which approach, what's the difference, help me think, can I, is it possible, design first, shape this, sketch a design, how should I structure, design the X before building. For quick inline design shaping; for a full committed spec and design gate, use m-brainstorming instead.

Collaborative design dialogue that turns a feature idea into an approved, committed design/spec before implementation. Use before creating features, building components, or adding functionality that lacks a written design. For quick inline shaping or advice, use m-ask instead. Triggers: brainstorm, design a feature, new feature, flesh out requirements, design before building.

Guides systematic root-cause debugging. Use when tests fail, builds break, behavior doesn't match expectations, or you encounter any unexpected error. Use when you need a systematic approach to finding and fixing the root cause rather than guessing. Triggers: test fails, build broken, stack trace, regression, flaky test, cannot reproduce, error in logs, root cause.

Executes a written implementation plan inline, task by task, following each step exactly and stopping at blockers. Use when a plan exists and subagent dispatch is unavailable or unwanted; otherwise prefer m-subagent-driven-development. Triggers: execute the plan, run the plan, implement the plan.

Use when implementation is complete, all tests pass, and you need to decide how to integrate the work - guides completion of development work by presenting structured options for merge, PR, or cleanup. Triggers: merge this, open a PR, we're done, finish the branch, clean up the worktree.

Builds production-quality UIs. Use when building or modifying user-facing interfaces. Use when creating components, implementing layouts, managing state, or when the output needs to look and feel production-quality rather than AI-generated. Examples assume React/Tailwind. Triggers: component, page, layout, UI, CSS, responsive, accessibility, a11y, form, modal, design polish.

Draft a Conventional Commits message that passes a commit-msg hook on the first try — type, scope, subject, body, breaking changes, fixup, branch and PR titles. Triggers: git commit, commit message, conventional commits, --amend, fixup, squash, PR title, branch name.

Optimizes application performance. Use when performance requirements exist, when you suspect performance regressions, or when Core Web Vitals or load times need improvement. Use when profiling reveals bottlenecks that need fixing. Triggers: slow, performance, latency, Core Web Vitals, LCP, bundle size, N+1 query, profiling, load time.

Evaluates code-review feedback with technical verification before implementing — no performative agreement, no blind implementation. Use when receiving review comments, especially unclear or questionable ones. Triggers: address review comments, PR feedback, reviewer said, fix review items.

Dispatches a fresh-context reviewer subagent against a git commit range and triages its findings by severity. Use after completing a task or feature, or before merging. Triggers: review my changes, code review, pre-merge check.

SDD phase 6 (optional gate) — cross-check constitution, spec, plan, and tasks for consistency and coverage before implementation; writes specs/<id>/analysis.md. Triggers: sdd analyze, consistency check sdd, validate spec plan tasks, sdd gate, pre-implementation review.

SDD optional quality gate — per-domain requirement-quality checklists ('unit tests for English') that test the spec's wording, not the implementation. Writes specs/<id>/checklists/<domain>.md. Triggers: sdd checklist, spec checklist, requirements quality, unit tests for english, requirement checklist, spec quality check, checklist the spec.

SDD phase 3 (optional) — resolve ambiguities in the spec by interviewing the user, appending a Clarifications section to specs/<id>/spec.md. Triggers: sdd clarify, clarify spec, resolve ambiguities, sdd questions, tighten spec.

SDD phase 1 — establish project principles, conventions, and guardrails that gate every later phase. Writes .sdd/constitution.md. Triggers: sdd constitution, project constitution, sdd principles, define guardrails, project conventions doc, establish standards.

SDD knowledge base — build .sdd/knowledge.md, a project-level index of facts/pointers (stack profile, file map, domain glossary, doc links, decisions) that specify and clarify read for grounding. Distinct from the constitution (rules). Triggers: sdd knowledge, knowledge base, project facts, sdd context, build knowledge, project glossary, ground specify, knowledge.md, sdd memory.

SDD phase 4 — produce the technical implementation plan by delegating to the m-writing-plans skill, writing specs/<id>/plan.md (+ research/data-model/contracts). Triggers: sdd plan, write sdd plan, plan feature sdd, implementation plan sdd, technical plan.

Spec-Driven Development orchestrator — scaffold .sdd/, create/select a feature, show pipeline status, and route to the next phase. Triggers: sdd, spec-driven, start sdd, sdd status, sdd init, new feature spec, what phase, which sdd phase, spec kit, speckit.

SDD phase 2 — turn a feature idea into an approved REQUIREMENT spec (what/why, PO-readable, no tech detail) through a convergent requirement-capture interview, writing specs/<id>/spec.md. Triggers: sdd specify, write sdd spec, specify feature, sdd spec, start spec, define requirements sdd, write requirements, feature spec for product owner, PO spec, requirement spec.

SDD phase 5 — normalize the plan's bite-sized steps into an ordered specs/<id>/tasks.md checklist. Triggers: sdd tasks, generate tasks sdd, task breakdown sdd, tasks from plan, sdd task list.

SDD phase 8 (optional) — push the feature's tasks.md to Jira as linked dev tickets by delegating to m-story-breakdown. Triggers: sdd tasks to issues, sdd to jira, create tickets from tasks, sdd issues, push sdd tasks to jira.

Hardens code against vulnerabilities. Use when handling user input, authentication, data storage, or external integrations. Use when building any feature that accepts untrusted data, manages user sessions, or interacts with third-party services. Triggers: auth, login, password, user input, upload, webhook, CORS, secrets, SQL injection, XSS, SSRF, LLM output, dependency audit.

Executes an implementation plan by dispatching a fresh subagent per task, with two-stage review (spec compliance, then code quality) after each task. Use when a written plan with mostly independent tasks exists and subagents are available. Triggers: execute plan with subagents, subagent driven, dispatch tasks.

Enforces test-driven development: write one failing test, watch it fail, write minimal code to pass, refactor — no production code without a failing test first. Use when implementing any feature, bugfix, or behavior change, before writing implementation code. Triggers: TDD, write tests first, red-green-refactor.

Deprecated — merged into m-worktree. Use m-worktree.

Isolated git worktree per feature branch — create, bootstrap, and clean up .worktrees/<branch> for parallel work without branch switching. Triggers: worktree, parallel branch, isolated workspace, new feature branch, git worktree, isolate my changes, work in parallel, don't touch my current branch.

Writes a detailed implementation plan — bite-sized TDD tasks with exact file paths, code, and verification commands — from an approved spec or requirements. Use for any multi-step task, before touching code. Triggers: write a plan, implementation plan, plan this feature, break this down.

Elay product — full git-to-PR workflow: craft a Conventional Commits message, branch correctly, run quality gates, and submit a compliant Draft PR with ADO story, description template, label, and assignee. Triggers: create PR, submit PR, open pull request, finish branch, push and PR, git commit PR, conventional commits PR, PR submission, PR checklist.