By xmtplabs
Agent skills for structured software delivery: spec writing, issue creation, task decomposition, and implementation
Use this agent when executing-plans exhausts max-3 remediation cycles. Receives spec, failed requirements, and current code with FRESH context (no prior failed attempts). Produces root-cause analysis and either a targeted fix plan or a blocking verdict.
Use this agent at phase boundaries to verify that implementation matches the plan — checks logic correctness, completeness, edge case handling, and boundary violations.
Use this agent to convert a design spec into a multi-file phased task plan. Produces plan.md (TOC + coverage), standards.md (one-time codebase context), and phase files under phases/ — Phase 1 and Verification fully elaborated; intermediate phases as sketches for just-in-time elaboration. Uses behavior-focused verification: TDD for behavior-bearing code and direct verification for mechanical artifact work. Runs codebase exploration in its own context so the main agent stays clean.
Use this agent at phase boundaries to review code organization, patterns, naming, and reuse opportunities. Absorbs simplify's concerns (reuse detection, deduplication, complexity reduction) without project-specific opinions.
Use this agent to implement a single task from a decomposed task list. Takes inline task text with context and produces working code with tests and verification.
Use when you have a design spec from writing-specs and need to break it into an implementable, phased task plan with behavior-focused verification before writing any code
Use when you have a plan directory from decomposing-specs and need to execute it — loads phases on demand, dispatches phase-elaborator for sketched phases, runs implementers with size-scaled phase reviews, and validates the full spec at the end
Use when a GitHub issue receives new comments during autonomous work — decides whether to update the spec and re-decompose, or just make the change inline
Use when configuring a repository to run with Code Factory — creates `.code-factory/config.toml`, sets up a devcontainer if missing, and validates that build/lint/test work inside it. Triggers on "setup code factory", "configure code factory", "onboard this repo to code factory".
Use when starting any feature, system change, or bugfix that requires architectural decisions — before writing implementation plans or code. Triggers on new projects, multi-component changes, API design, or when the user says "design", "spec", or "architecture".
Uses power tools
Uses Bash, Write, or Edit tools
Own this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimOwn this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimBased on adoption, maintenance, documentation, and repository signals. Not a security audit or endorsement.
Agent plugin for structured software delivery. Each skill can be used independently or chained together into an end-to-end pipeline.
Rough idea → writing-specs → decomposing-specs → executing-plans → Human review
↑ |
| User approves spec |
+--------------------- feedback -----------------------+
For autonomous work via GitHub issues:
GitHub issue → coder-task → classify (bug/feature) → spec → decompose → execute → PR
decomposer subagent that explores the codebase and writes a multi-file plan: plan.md (TOC + coverage matrix), standards.md (one-time codebase context shared across phases), and per-phase files. Phase 1 + Verification ship fully elaborated; intermediate phases as sketches. Scoped plan-reviewer and task-list-reviewer validate the elaborated portion before hand-off.plan.md + standards.md only; reads phase files on demand. At phase boundaries, dispatches phase-elaborator to flesh out sketched phases against the current codebase, with one-phase-ahead elaboration allowed during Tier B/C review and adjusted afterward if review fixes materially change the prior phase. Then dispatches implementer subagents (with batching for cohesive consecutive tasks, parallel for [P] tasks). Phase-boundary review depth scales to phase size; severity-gated re-review prevents ping-pong. Runs CI checks, final full-spec review, and auto-debug escalation if remediation fails.Each skill produces a file artifact and can be invoked independently:
writing-specs → docs/plans/YYYY-MM-DD-<topic>-design.mddecomposing-specs → docs/plans/YYYY-MM-DD-<topic>/ (multi-file: plan.md, standards.md, phases/NN-*.md — Phase 1 + Verification fully elaborated; intermediate phases sketched and elaborated just-in-time by executing-plans)| Skill | Description |
|---|---|
writing-specs | Collaborate on a design spec with EARS requirements, clarification markers, and brownfield gap analysis |
decomposing-specs | Dispatch a decomposer subagent to write a multi-file phased plan (Phase 1 + Verification elaborated; rest sketched for just-in-time elaboration) |
executing-plans | Execute a multi-file plan with on-demand phase loading, just-in-time or one-phase-ahead elaboration, batched/parallel implementer dispatch, size-scaled phase reviews, and auto-debug escalation |
audit-tests | Audit test suites for low-value, brittle, duplicative, or AI-generated tests and produce a precise cleanup plan |
coder-task | End-to-end: GitHub issue → classify bug/feature → spec → tasks → implementation → PR on a fork |
code-factory | v2 of coder-task: same flow with scripted fork/branch/PR steps, requester-as-reviewer, and selective feedback handling |
receiving-feedback | Classify new issue comments as trivial (do inline) vs. meaningful (update spec, re-decompose) — used by code-factory |
bugfix | Produce a 3-section bugfix spec (Current/Expected/Unchanged Behavior) — dispatched by coder-task, not invoked directly |
setup-code-factory | Onboard a repo to Code Factory: write .code-factory/config.toml, create a devcontainer if missing, and validate build/lint/test inside it |
npx claudepluginhub xmtplabs/code-factory --plugin code-factorySpecification-driven development workflow: specify → plan → tasks → implement
Skills-first specification-driven development framework with 7 agent skills for planning, implementation, review, and shipping. Natural language activation with intelligent agent orchestration. Includes /plan, /implement, /research commands plus managing-specifications, implementing-features, and reviewing-and-shipping skills.
Spec-driven development using GitHub spec-kit methodology. Constitution-first approach with specify, plan, tasks, and implement phases.
Provider-agnostic skills for autonomous product development: spec, task, implement, test, review, and summarize changes.
Spec-driven development for big features. When features get too big, plan mode gets too vague—leading to hallucinations during implementation. ShipSpec replaces vague plans with structured PRDs, technical designs, and ordered tasks that keep Claude grounded.
Persona-driven AI development team: orchestrator, team agents, review agents, skills, slash commands, and advisory hooks for Claude Code