edf

Plugin edf from marketplace mironyx in mironyx/engineering-delivery-framework. Commands read from the repo's manifest — today.

Skills (24)

• architect

  Read a plan document and produce all design artefacts in one pass (ADRs, LLDs, design doc updates, enriched issue bodies), so edf:feature agents can implement against approved designs.

• backlog

  Run backlog maintenance. Reads the project board, open issues, all requirements docs (current and future), recent session logs, retros, drift reports, and ADRs; produces a propose-only grooming report that recommends ≥10 next items, flags backlog health, surfaces coverage gaps, sanity-checks the cur

• baseline

  Reconcile reality (code, issues, docs, git history) into a consolidated as-built requirements document. Produces a point-in-time snapshot in docs/reports/baseline/. Use at phase transitions, before from-scratch reimplementations, or when requirements docs feel stale. Propose-only — never mutates req

• bug

  Investigate a bug from a vague symptom, error message, or behaviour description. Researches the codebase to find root cause, checks for LLD gaps, and creates a well-formed GitHub issue ready for edf:feature. Use when the user reports a bug, error, unexpected behaviour, or says something like "X is b

• create-adr

  Create an Architecture Decision Record. Use when making any significant technical decision, choosing between alternatives, or when the user mentions ADR, architecture decision, or design choice. Also use when discussing trade-offs between approaches.

• create-mermaid-diagram

  Create a Mermaid diagram. Use when the user wants to visualise architecture, flows, sequences, data models, state machines, or any relationships. Also use when discussing system design, workflows, or entity relationships where a diagram would aid comprehension.

• create-plan

  Create a detailed implementation plan for a feature, phase, or epic, derived from an existing HLD. Use when an HLD already exists and a phase or epic needs planning. Do NOT use for initial project bootstrap — use edf:kickoff instead, which owns HLD + plan together. See ADR-0021.

• diag

  Run CodeScene health checks on changed files, plus SonarQube MCP analysis when `sonar` is passed, then check diagnostics-exporter output if `.diagnostics/` exists. Use when the user wants to check code quality, review diagnostics, or before committing code.

• discovery

  Explore a problem space from a freeform idea using adapted Lean Inception activities. Produces a structured discovery document with product vision, boundaries, personas, user journeys, features, and MVP sequencing. Use before edf:kickoff when starting a new project or major version. Web research inc

• drift-scan

  Run garbage collection scan for drift between requirements, design artefacts, and implemented code. Use when completing a batch of changes, before starting a new phase, or at session end when significant code was written. Produces a drift report in docs/reports/.

• feature-core

  Core implementation cycle: read design, TDD, verify, diagnostics, commit, PR, CI probe, review, report. Called by edf:feature and edf:feature-team skills after branch setup.

• feature-end

  USER-INVOKED ONLY — never invoke this skill yourself, and never chain into it from /feature, /feature-core, or any other skill. Wraps up a feature after the human has reviewed the PR — writes session log, merges PR, cleans up. The user typing /feature-end IS the merge approval; the model deciding to

• feature-team

  Parallel feature implementation using Claude Code agent teams. Lead defines tasks; each teammate autonomously implements one issue in its own git worktree. Requires Claude Code CLI.

• feature

  Autonomously implement the next feature from the project board. Picks the top Todo item, creates a branch, implements with TDD, runs diagnostics, commits, creates a PR, runs edf:pr-review and fixes any findings, then reports. Only pauses for real blockers. Never merges — ends at the report; the huma

• frontend-architect

  Establish the frontend design system before any UI feature work. Surveys existing pages and components, commits to a bold aesthetic direction (drawing on /frontend-design thinking), chooses a CSS framework, defines design tokens, and produces docs/design/frontend-system.md as the spec all subsequent

• kickoff

  Bootstrap a project version from a versioned requirements document. Produces the HLD (Levels 1–3, full or delta), load-bearing ADRs, an epic-shaped plan, and epic issues — with human gates after each. Version slug derived from the requirements filename. Use at the start of v1 or any major version (v

• lld-sync

  Sync the LLD back to the implementation after a feature is complete. Reads the design spec and the actual code, produces a structured diff, and updates the LLD in-place. Run after implementation, before edf:feature-end.

• lld

  Generate Low-Level Design documents for implementation plan sections. Produces LLDs with implementation-level detail, file paths, internal types, and task breakdowns. Use for preparing a phase or section before implementation.

• pr-review

  Review code changes for bugs, design principles, contract adherence, external surface currency, and design conformance. Use before committing (/pr-review) or on a PR (/pr-review 123). Adaptive: 1 agent for small diffs, 2 agents for large diffs. Agent B (surface currency) runs on either path, only on

• qa

  Quality assurance — executes E2E tests via Playwright, validates integration contracts, audits cross-story coverage, and produces a quality gate report. Invoked after edf:lld, before edf:feature, or post-implementation against a running app.

• refactor-architect

  Decompose a refactor (smell, tech debt, audit finding, or freeform intent) into well-formed GitHub issue(s). Produces one task issue by default, or an epic + N task issues for refactors too large for a single PR. The parallel of /architect for refactor work — same decomposition discipline, reuses /a

• requirements

  Transform discovery output or a freeform brief into a structured requirements document with epics, prioritised user stories, and testable acceptance criteria. Use after edf:discovery (or standalone for smaller projects) and before edf:kickoff.

• retro

  Run a process retrospective. Reviews recent sessions, git history, issue board state, and drift reports to identify what's working, what isn't, and what to change. Use at the end of a project phase, after 3-5 sessions of active work, or before starting multi-agent parallel work. Produces a report in

• setup

  Bootstrap an existing project with EDF conventions. Detects project language and existing artefacts, scaffolds kb/ and CLAUDE.md, configures .env/.gitignore, and verifies the result. Run after installing the EDF plugin to configure project-level files.

Subagents (14)

• ci-probe

  Background agent that polls for a GitHub Actions CI run to complete, then reports any failures. Uses status polling (not gh run watch) to minimise token usage. Launch as a background agent immediately after git push, passing the PR number and the resolved ci-status command.

• diagnostics-checker

  Background agent that reads VS Code extension diagnostics from .diagnostics/ folder after code changes. Waits for diagnostics to be generated, then reports issues found. Launch as a background agent after writing or editing source files.

• feature-evaluator

  Audits coverage of a completed feature implementation against its LLD acceptance criteria. Confirms that the test file produced by the `edf:test-author` sub-agent covers every contract property, and writes adversarial tests only for genuine gaps. Spawned by feature-core after /diag, before PR creati

• gh-issue-manager

  Creates multiple task issues and updates the epic body in one batch via gh CLI. Runs without confirmation prompts (parent skill already got user approval). Used by /architect after LLD generation.

• hld-review

  Reviews a High-Level Design document after drafting and before the human gate. Checks capability-to-component traceability, component boundary completeness, interaction coverage, trust boundary explicitness, ADR triggers, delta-mode reference resolution, and technology-free naming. Spawned by /kicko

• lld-review

  Reviews a Low-Level Design document after the self-critique pass and before task breakdown. Two tiers: (1) design quality — is this a good design given constraints and trade-offs? (2) mechanical completeness — are contracts, specs, and references complete enough for a /feature agent to implement aga

• qa-contracts

  Validates API integration contracts from the LLD against reality. Pre-mode: greps codebase for function signatures, DB schemas, and route patterns matching LLD contracts. Post-mode: sends HTTP requests and validates response shapes and status codes. Spawned by /qa Step 3. Returns a compact pass/fail

• qa-coverage

  Audits cross-story coverage by reading the coverage manifest and requirements doc, then cross-referencing every REQ- anchor against manifest entries. Flags uncovered requirements, missing LLD sections, stale drafts, and missing issues. Spawned by /qa Step 5. Returns a compact gap report.

• qa-executor

  Executes a single QA scenario against a running application using Playwright MCP. Navigates, interacts, asserts expected behaviour, and returns a compact pass/fail verdict with evidence. Spawned by /qa for each E2E scenario extracted from the LLD.

• qa-explorer

  Exploratory QA agent that uses the LLD as context to hunt for breakage. Walks the happy path once, then attacks edges: input boundaries, interaction abuse, state manipulation, error handling, and visual stress. Self-manages against a time budget. Spawned by /qa in exploratory mode, one per epic.

• requirements-design-drift

  Garbage collection agent that detects drift between requirements, design artefacts, and implementation code. Use when asked to scan for drift, check coverage, run garbage collection, or audit alignment between requirements, design documents, and source code. Also invoked via /drift-scan command.

• requirements-review

  Reviews a requirements document before each human gate. Checks INVEST compliance, AC testability, cross-reference completeness, anchor presence, and internal consistency. Spawned by /requirements before Gate 1 and Gate 2.

• test-author

  Writes thorough tests against spec and requirements before implementation exists. Reads requirements, LLD, and issue; identifies observable contract properties; writes test file using project conventions. Spawned by feature-core Step 4b (Standard/Heavy pressure path) before implementation.

• test-runner

  Runs test, typecheck, lint, build, and e2e commands via wrapper scripts, reporting only a compact pass/fail verdict regardless of test volume. Spawned by feature-core Steps 4c and 5 for all verification runs.

Hooks (3)

• PostToolUse

  ${CLAUDE_PLUGIN_ROOT}/hooks/open-in-editor.sh

• PostToolUse

  ${CLAUDE_PLUGIN_ROOT}/hooks/check-diagnostics.sh

• PreCompact

  ${CLAUDE_PLUGIN_ROOT}/hooks/run-python.sh ${CLAUDE_PLUGIN_ROOT}/bin/pre-compact-session-log.py

Similar plugins