By yamchinsky
The complete Spec-Driven Development workflow: spec-creator, implementation-planner, implementer, and plan-verifier agents plus the run-plan orchestrator, manual workflow-retro, and engineering-insights capture — wired to shared knowledge skills, a research agent, and an architecture-review gate via plugin dependencies.
Use proactively at the start of any non-trivial feature or change, before implementation — or when asked to plan, scope, decompose, or design an approach. Takes EXISTING requirements as input (from the request or a spec document), verifies them against the codebase, and recommends improvements. If requirements are unclear or the execution mode (multi-agent vs single-agent) is not stated, it returns clarifying questions INSTEAD of a plan — relay them to the user and re-invoke with the answers. Once confirmed, writes a structured Implementation Plan to docs/plans/<feature>.md: requirement traceability IDs, tasks with owned paths, per-task skills, a dependency DAG (multi-agent) or sequential steps (single-agent), and measurable acceptance criteria. Read-only on product code; its ONLY write is the plan file. Does NOT write specifications. Does NOT implement. Callers SHOULD gather the execution mode (multi-agent vs single-agent) and requirement confirmations via AskUserQuestion BEFORE invoking — a stated mode avoids a second invocation through the clarification gate.
Use proactively to execute ONE task of an Implementation Plan (docs/plans/<feature>.md) — backend or UI — and as several parallel instances, one per disjoint task. Works in the same branch/working tree it was launched in; owns only its task's paths. Returns a report: files changed, skills applied, and green typecheck + existing-tests output (or the documented typecheck-only fallback when the project has no test command).
Use to verify that an implemented change satisfies every requirement and acceptance criterion of an Implementation Plan in `docs/plans/<feature>.md`. Maps every R-ID and measurable acceptance criterion to concrete evidence (file:line, test name, migration) and returns a coverage matrix with an ALL COVERED / GAPS FOUND verdict; cross-checks spec ACs when the plan names a SPEC-NN. Read-only; complements quality review and structural architecture review — this one is COVERAGE. Invoked by the `sdd-engineering:run-plan` skill after the last implementer wave, or directly via 'verify the plan', 'did we cover all requirements', 'requirement coverage', 'check plan against code'.
Use to write a Spec-Driven Development (SDD) feature specification BEFORE any planning or implementation — problem, goals/non-goals, user stories, EARS acceptance criteria, edge cases, input provenance. Grounds facts in the repository (docs, code search, and optional convention tools when the host project exposes them), critiques provided designs/code/docs for gaps, and interviews the user through STOP-AND-RETURN question rounds (it cannot ask live — relay its questions to the user and re-invoke with the answers; repeat until it writes the spec). Writes ONLY SPEC-NN-*.md files (plus the folder README index line) under a specs/ folder. Trigger phrases: 'write a spec', 'create a specification', 'SDD spec', 'напиши специфікацію', 'створи спеку'. Does NOT plan tasks (sdd-engineering:implementation-planner) and does NOT document shipped features.
Use during any coding session whenever you uncover a non-obvious finding worth preserving — a failure mode that surprised you, a tool/library quirk, an architectural decision made for a non-obvious reason, a recurring error and its fix, or an open question you could not resolve. Appends a single dated entry to the nearest INSIGHTS.md (the closest ancestor of the affected files, or the repo root) under one of seven fixed sections. Append-only. Skips anything obvious from reading the code.
Use to EXECUTE an Implementation Plan (`docs/plans/<feature>.md`) end-to-end in the main session: feature branch → implementer waves per the task DAG (or sequential steps in single-agent mode) → plan-verifier coverage gate (run inside a subagent) → capped gap-fix loop → architecture review gate with a capped fix loop (≤3, until PASS) → spec status flip → confirm and `gh pr create`. Trigger phrases: '/run-plan', '/impl', 'імплементуй план', 'implement the plan', 'run the plan', 'execute the plan', 'виконай план', 'запусти план'. NOT for writing plans (sdd-engineering:implementation-planner) or specs (sdd-engineering:spec-creator) — those are invoked manually, upstream of this skill.
Use to run a MANUAL retrospective of a multi-agent run (the SDD pipeline or any session with subagents): computes token metrics (input / output / cache-read / cache-creation, cache-hit rate), tool-call counts, durations, and parallelism — INCLUDING nested subagents, whose usage the parent does not count (deep mode reads their journals from disk) — then produces insights + concrete recommendations and appends a trend row to docs/retros/ledger.md. Trigger phrases: 'workflow retro', 'ретро прогону', 'retro the run', '/workflow-retro'. Manual only — never fired by a hook.
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.
A Claude Code plugin marketplace for the DevDigest team AI harness. It packages the reusable parts of the harness — the SDD (Spec-Driven Development) workflow, shared engineering skills, a research agent, and a generalized architecture reviewer — so any team repository can install them without copying files from the DevDigest working tree.
| Plugin | What it provides | Depends on |
|---|---|---|
engineering-paved-path | 12 shared knowledge skills (React, Next.js, Fastify, Drizzle, PostgreSQL, Zod, TypeScript, security, onion architecture, Mermaid, testing) | — |
research-tools | researcher — generic read-only research agent (codebase + web) | — |
architecture-review | architecture-reviewer — audits diffs against the repository's own documented architecture rules | engineering-paved-path |
sdd-engineering | The SDD workflow: spec-creator, implementation-planner, implementer, plan-verifier agents; run-plan, workflow-retro, engineering-insights skills | all three above |
The DevDigest harness files were classified into four groups. Only the first group ships here.
| Group | Components | Disposition |
|---|---|---|
| Reusable | 12 knowledge skills (React/Next/Fastify/Drizzle/PostgreSQL/Zod/TypeScript/security/onion-architecture/Mermaid/testing); researcher; architecture-reviewer (generalized); spec-creator, implementation-planner, implementer, plan-verifier; run-plan (formerly impl), workflow-retro, engineering-insights (generalized); their references and eval scenarios | Extracted into the four plugins after an editorial pass that removed every DevDigest-specific path, module name, and bare-name reference |
| Project-specific | DevDigest CLAUDE.md, pr-self-review skill + hooks, architecture-reviewer-lite, doc-writer, dependency-checker, the vitest eval harness, the devdigest MCP server, product specs | Stay in the DevDigest repository — they encode its modules, contracts, and CI |
| Optional integrations | Convention MCP tools used by spec-creator for grounding | Removed from required tools:; the agent falls back to CLAUDE.md/docs/code search when absent |
| Local leftovers | Caches, personal memory, experiment workspaces, absolute paths | Not extracted |
Why each reusable component updates together with the SDD workflow: the
workflow is the consumer contract — run-plan dispatches
sdd-engineering:implementer and the review gates, the planner assigns
engineering-paved-path:* skills to tasks, and the spec/plan formats are the
interfaces between the agents. Components with an independent consumer
scenario (researcher, architecture-reviewer, the knowledge skills) live in
their own plugins and are consumed as version-constrained dependencies;
workflow-retro has no consumer scenario outside the SDD lifecycle, so it
stays inside sdd-engineering and is invoked manually only.
claude plugin marketplace add yamchinsky/dev-digest-ai-marketplace
claude plugin install sdd-engineering@dev-digest-ai-marketplace --scope project
Installing sdd-engineering automatically installs its three dependencies;
the install output lists them at the end.
A searchable static catalog is published on GitHub Pages:
https://yamchinsky.github.io/dev-digest-ai-marketplace/. It is generated
from the repository files (scripts/build-index.mjs) — never edited by hand.
.claude-plugin/marketplace.json # the catalog manifest
plugins/<name>/ # one directory per plugin (source of truth)
docs/ # guidelines, security, releases, site spec
scripts/build-index.mjs # generates the site search index
site/ # static catalog UI (Vite + React)
Plugin versions live in each plugin's plugin.json. A marketplace commit or
tag pins the state of the catalog; releases are immutable git tags of the form
{plugin-name}--v{version}.
npx claudepluginhub yamchinsky/dev-digest-ai-marketplace --plugin sdd-engineeringGeneric read-only research agent: looks things up in the current codebase (with path:line evidence) or on the web (with source URLs), reports in a strict structure, and asks clarifying questions when the request is ambiguous.
Twelve shared engineering knowledge skills: React, React Testing Library, Next.js, frontend architecture, Fastify, onion architecture, Drizzle ORM, PostgreSQL table design, Zod, TypeScript, web security (OWASP), and Mermaid diagrams.
Architecture review gate: audits a diff against the repository's own documented structural contracts (docs/architecture/ or ARCHITECTURE.md) and returns findings with rule identifiers, verbatim evidence, and a PASS / FAIL / NOT-APPLICABLE verdict.
Consult multiple AI coding agents (Gemini, OpenAI, Grok, Perplexity, plus codex, antigravity, and grok CLIs when installed) to get diverse perspectives on coding problems
Harness-native ECC operator layer - 67 agents, 278 skills, 94 legacy command shims, reusable hooks, rules, selective install profiles, and production-ready workflows for Claude Code, Codex, OpenCode, Cursor, and related agent harnesses
Comprehensive skill pack with 66 specialized skills for full-stack developers: 12 language experts (Python, TypeScript, Go, Rust, C++, Swift, Kotlin, C#, PHP, Java, SQL, JavaScript), 10 backend frameworks, 6 frontend/mobile, plus infrastructure, DevOps, security, and testing. Features progressive disclosure architecture for 50% faster loading.
Develop, test, build, and deploy Godot 4.x games with Claude Code. Includes GdUnit4 testing, web/desktop exports, CI/CD pipelines, and deployment to Vercel/GitHub Pages/itch.io.
A growing collection of Claude-compatible academic workflow bundles. Covers scientific figures, manuscript writing and polishing, reviewer assessment, citation retrieval, data availability, paper reading, literature search, response letters, paper-to-PPTX conversion, and evidence-grounded Chinese invention patent drafting. Rules are organized as reusable skill folders with explicit workflows and quality checks.
Matt Pocock's agent skills for real engineering — grilling, spec/ticket flows, TDD, code review, domain modelling and more. Plug-and-play, not vibe coding.