Skip to content
Back to search

disciplined-agentic-engineering

SkillGitHubIncomplete

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/swingerman/engineer with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/swingerman/engineer'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/swingerman--engineer/badge.svg)](/listings/swingerman--engineer)

HTML

<a href="/listings/swingerman--engineer"><img src="/api/listings/swingerman--engineer/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Install

On Claude Code:

/plugin marketplace add swingerman/engineer

/plugin install engineer@disciplined-agentic-engineering      # the DAE methodology kit
/plugin install atdd@disciplined-agentic-engineering          # ATDD + differential mutation testing
/plugin install crap-analyzer@disciplined-agentic-engineering # change-risk analysis

Or run from a clone:

git clone https://github.com/swingerman/engineer.git
claude --plugin-dir ./engineer

Your first feature

/engineer.onboard        # once per project — charter, manifest, tracker
/engineer.next           # every session — "what should I pick up?"
/engineer.discuss        # an idea → drop, park, or promote to a feature

From there the pipeline tells you the next command at every step. Each checkpoint ends with a handoff naming what comes next, and `/engineer.next` reconstructs that at any time.

---

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 59 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "name": "disciplined-agentic-engineering",
  3. "owner": {
  4. "name": "Miklos",
  5. "email": ""
  6. },
  7. "metadata": {
  8. "description": "Disciplined Agentic Engineering — a methodology kit for Claude Code: the engineer, atdd, and crap-analyzer plugins, grounded in Uncle Bob's acceptance-test approach",
  9. "version": "1.24.0"
  10. },
  11. "plugins": [
  12. {
  13. "name": "atdd",
  14. "source": "./",
  15. "description": "Acceptance Test Driven Development for Claude Code. Enforces the ATDD methodology: write Given/When/Then specs first, generate a project-specific test pipeline, maintain two test streams (acceptance + unit). Inspired by Robert C. Martin's acceptance test approach from empire-2025.",
  16. "version": "0.8.4",
  17. "author": {
  18. "name": "Miklos"
  19. },
  20. "homepage": "https://github.com/swingerman/engineer",
  21. "repository": "https://github.com/swingerman/engineer",
  22. "license": "MIT",
  23. "keywords": ["atdd", "acceptance-testing", "tdd", "given-when-then", "spec-driven-design", "uncle-bob", "bdd"],
  24. "category": "development-workflows",
  25. "tags": ["testing", "methodology", "acceptance-tests", "spec-driven-design", "ai-development"]
  26. },
  27. {
  28. "name": "engineer",
  29. "source": "./engineer",
  30. "description": "Disciplined Agentic Engineering (DAE) — methodology kit for Claude Code. Skills that implement the DAE pipeline: feature intake, AC discovery, spec writing, planning, implementation, verification, hardening.",
  31. "version": "0.40.2",
  32. "author": {
  33. "name": "Miklos"
  34. },
  35. "homepage": "https://github.com/swingerman/engineer",
  36. "repository": "https://github.com/swingerman/engineer",
  37. "license": "MIT",
  38. "keywords": ["dae", "disciplined-agentic-engineering", "methodology", "ai-development", "tdd", "atdd", "engineering"],
  39. "category": "development-workflows",
  40. "tags": ["methodology", "ai-development", "engineering-workflow", "spec-driven-design"]
  41. },
  42. {
  43. "name": "crap-analyzer",
  44. "source": "./crap-analyzer",
  45. "description": "Analyze recently-changed code for Change Risk Anti-Patterns. Multi-language (TS/JS, Python, Java, Kotlin, Go, Ruby, C#, Rust, PHP) with auto-discovered coverage toolchain. Part of DAE's Light Verify tier (Checkpoint 7).",
  46. "version": "0.1.1",
  47. "author": {
  48. "name": "Miklos Szanyi",
  49. "url": "https://github.com/swingerman"
  50. },
  51. "homepage": "https://github.com/swingerman/engineer/tree/main/crap-analyzer",
  52. "repository": "https://github.com/swingerman/engineer",
  53. "license": "MIT",
  54. "keywords": ["code-quality", "testing", "coverage", "refactoring", "cyclomatic-complexity", "crap"],
  55. "category": "code-quality",
  56. "tags": ["testing", "coverage", "refactoring", "complexity", "dae"]
  57. }
  58. ]
  59. }
README.md · README · 544 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # Disciplined Agentic Engineering (DAE)
  2. *A methodology kit for engineering-led AI development — spec-driven, test-driven, charter-bound. ATDD + mutation testing + deterministic guardrails.*
  3. [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
  4. [![Reference host: Claude Code](https://img.shields.io/badge/reference%20host-Claude%20Code-blueviolet)](https://github.com/swingerman/engineer)
  5. **AI agents do the typing. Engineers stay in charge of architecture, behavior contracts, and verification.** DAE puts the discipline in *deterministic tools the agent has to satisfy* — not in prompt rules that erode over long runs.
  6. The methodology is host-independent. It ships today as three plugins for **Claude Code**, the reference host — see [Host independence](#host-independence).
  7. > ℹ️ **Repo renamed** to `swingerman/engineer` (formerly `swingerman/atdd`, then `swingerman/disciplined-agentic-engineering`). Old URLs still redirect; update remotes only if you want to: `git remote set-url origin https://github.com/swingerman/engineer.git`. The marketplace is still named `disciplined-agentic-engineering` — install refs (`@disciplined-agentic-engineering`) are unchanged.
  8. ---
  9. ## Contents
  10. | | |
  11. |---|---|
  12. | **[Quick start](#quick-start)** · [Install](#install) · [Your first feature](#your-first-feature) | Get running |
  13. | **[How it works](#how-it-works)** · [The pipeline](#the-pipeline) · [Guardrails](#the-guardrails) · [Autonomy](#tunable-autonomy) | The methodology |
  14. | **[The three plugins](#the-three-plugins)** · [`engineer`](#engineer--the-methodology-kit) · [`atdd`](#atdd--acceptance-test-driven-development) · [`crap-analyzer`](#crap-analyzer--change-risk) | What's in the box |
  15. | **[Host independence](#host-independence)** | Porting to another runtime |
  16. | **[Why not vibe coding](#why-not-vibe-coding)** · [Who it's for](#who-its-for) · [Background](#background--influences) | The argument |
  17. | **[Repo layout](#repo-layout)** · [Contributing](#contributing) | Reference |
  18. ---
  19. ## Quick start
  20. ### Install
  21. On Claude Code:
  22. ```shell
  23. /plugin marketplace add swingerman/engineer
  24. /plugin install engineer@disciplined-agentic-engineering # the DAE methodology kit
  25. /plugin install atdd@disciplined-agentic-engineering # ATDD + differential mutation testing
  26. /plugin install crap-analyzer@disciplined-agentic-engineering # change-risk analysis
  27. ```
  28. Or run from a clone:
  29. ```bash
  30. git clone https://github.com/swingerman/engineer.git
  31. claude --plugin-dir ./engineer
  32. ```
  33. ### Your first feature
  34. ```shell
  35. /engineer.onboard # once per project — charter, manifest, tracker
  36. /engineer.next # every session — "what should I pick up?"
  37. /engineer.discuss # an idea → drop, park, or promote to a feature
  38. ```
  39. From there the pipeline tells you the next command at every step. Each checkpoint
  40. ends with a handoff naming what comes next, and `/engineer.next` reconstructs
  41. that at any time.
  42. ---
  43. ## How it works
  44. DAE operates on **features** — numbered folders that accumulate a stack of
  45. progressively-sharper specs, Speckit-style:
  46. ```
  47. feature.md → acs.md → spec.md → plan.md
  48. intent behavior Gherkin architecture
  49. (domain (executable)
  50. language)
  51. ```
  52. Each layer is reviewed and approved before the next is written, and constrains
  53. the ones below it. The folder also holds `handoffs/` (the audit trail) and
  54. `.build/` (generated IR and pipelines).
  55. ### The pipeline
  56. Eight checkpoints, each gated on the previous one's handoff:
  57. ```
  58. 0 Onboard → 1.5 Ready → 2 ACs → 3 Spec → 4 Plan → 5 Implement → 6 Refine → 7 Verify → 8 Harden
  59. ```
  60. | # | Stage | Command | What happens |
  61. |---|---|---|---|
  62. | **0** | Onboard | `/engineer.onboard` | Once per project. Human signs off the **charter** (architecture, conventions, quality + autonomy stance); manifest and `features/` layout produced. |
  63. | **1.5** | Ready | `/engineer.feature-init` | `feature.md` records outcome, scope, owner, autonomy level, branch. The contract for *what we're building*. |
  64. | **2** | ACs | `/engineer.discover-acs` | Four-pass interview — happy path, edges, errors & security, cross-cutting. Output `acs.md` in domain language. Reviewed by an adviser + devil's-advocate panel. |
  65. | **3** | Spec | `/engineer.atdd` → `atdd:atdd` | ACs become standard Gherkin in `spec.md`; a project-specific test pipeline is generated. Leakage caught by `spec-guardian`. |
  66. | **4** | Plan | `/engineer.plan` | Architecture plan + structured **Charter Check**. Human confirms the architecture before the rest drafts. Panel-reviewed. |
  67. | **5** | Implement | `/atdd:atdd-team` | Fresh-per-phase agent team implements against the specs. **Two test streams** (acceptance + unit) must go green together. |
  68. | **6** | Refine | `/engineer.refine` | Parallel review across Reuse / Quality / Efficiency, fed deterministic duplicate findings, filtered through the charter. |
  69. | **7** | Verify | `/engineer.arch-check` + `crap-analyzer` | Architecture fitness (layering, cycles, forbidden patterns, naming, size) + change-risk on the diff. **A different agent than the implementer.** |
  70. | **8** | Harden *(optional)* | `/atdd:atdd-mutate` | **Differential mutation testing** proves the unit tests actually catch bugs. |
  71. **Or run it coordinated.** `/engineer.run <feature>` drives CP2 → CP8 as an
  72. **agent orchestration graph**. A coordinator proposes the graph up front: the
  73. shape of each segment (Chain, Fan-out, Diamond, Star, Loop, Feedback), each
  74. node's model class and loop cap, and a rough token and wall-clock estimate. It
  75. then dispatches every checkpoint as a fresh agent and stops only at the **front
  76. gate** (ACs + spec + plan) and the **back gate** (did it work). It stays thin: it
  77. reads handoffs and script output, never source code. Every loop has a hard cap
  78. and a no-progress stop, and every fan-out is checked by evidence from outside it
  79. (a tool run or a human), so parallel agents cannot just agree with each other.
  80. An XS feature skips all of this and goes straight to `/engineer.express`. The
  81. skills above still work standalone, unchanged. See
  82. [`coordinator.md`](engineer/references/coordinator.md) and
  83. [`graph-shapes.md`](engineer/references/graph-shapes.md).
  84. Cross-cutting, any time: `clarify` · `consistency-check` · `feature-edit` ·
  85. `progress-log` · `reorient` · `session-summary` · `next`.
  86. ### The guardrails
  87. **Every checkpoint is gated by tools, not by prompt rules.** An agent can talk
  88. itself out of an instruction; it cannot talk itself out of a non-zero exit code.
  89. At each checkpoint's Step 0:
  90. | Gate | Script | Enforces |
  91. |---|---|---|
  92. | **Entry** | `dae_handoff.py` | The prior checkpoint's handoff exists, `status: complete`, every exit criterion met |
  93. | **Branch** | `dae_branch.py` | You're on the feature's branch (`git.manual: true` opts out) |
  94. | **Ontology** | `dae_ontology.py` | Artifact-graph constraints — enumerations, AC↔scenario coverage, verifier ≠ implementer or refiner |
  95. | **Breadcrumb** | `dae_progress.py` | Passive "you are here" across the pipeline + roadmap |
  96. All 26 scripts are **stdlib-only Python 3**, each with a `test_*.py` sibling —
  97. 533 tests. No dependencies is a deliberate portability constraint, not an
  98. aesthetic one.
  99. <details>
  100. <summary><b>The full guardrail set</b></summary>
  101. | Script | Purpose |
  102. |---|---|
  103. | `dae_resolve.py` | Methodology-root + manifest resolver; central schema validation |
  104. | `dae_handoff.py` | Handoff-as-gate; project-wide status survey |
  105. | `dae_branch.py` | Branch hygiene at every checkpoint entry |
  106. | `dae_progress.py` | Pipeline breadcrumb + roadmap position |
  107. | `dae_ontology.py` | Artifact-graph constraint checks (see `references/ontology.md`) |
  108. | `dae_arch.py` | Architecture fitness — layering, cycles (Tarjan's SCC), naming, file size |
  109. | `dae_impact.py` | Test Impact Analysis — run only the scenarios a change affects |
  110. | `dae_mutmap.py` | Differential mutation — re-mutate only what changed |
  111. | `dae_dup.py` | Duplicate-code detection (`jscpd` by default, configurable), fed into Refine's Reuse lens |
  112. | `dae_gherkin.py` | Portable Gherkin → IR parser (+ `_convert`, `_mutate` siblings) |
  113. | `dae_reconcile.py` | Reconciles feature state against git/PR reality |
  114. | `dae_release.py` | Version bump + cache sync for the plugins themselves |
  115. | `dae_commit.py` | Commit with bounded retry and safe stale-lock removal |
  116. | `dae_roadmap.py` · `dae_tracker_local.py` | Roadmap + tracker drivers |
  117. | `dae_delegable.py` | Cloud-vs-local dispatch routing |
  118. | `dae_diverse.py` | Second-model-family review gate (L/XL or charter-flagged; never XS/S) |
  119. | `dae_infra.py` | Declared infrastructure probe / start / teardown |
  120. | `dae_introvert.py` | Flags tests that pass without asserting on output |
  121. | `dae_fix.py` | Bug-fix lifecycle + gap analysis |
  122. | `dae_graph.py` | Validates `/engineer.run`'s graph: loop caps, outside evidence for fan-outs, no segment spanning a human gate |
  123. </details>
  124. ### Handoffs
  125. Every agentic task ends with a structured handoff — frontmatter plus body —
  126. carrying its checkpoint, artifacts, exit-criteria assertions, panel findings, and
  127. `recommended_next`. Two jobs:
  128. - **You** know when to re-engage after walking away.
  129. - **The next checkpoint's entry gate** uses it to decide whether it may proceed.
  130. A checkpoint is not done until its handoff says so and the tools agree.
  131. ### Tunable autonomy
  132. Every feature carries an explicit **autonomy level** — how much the agent
  133. decides alone versus asking for sign-off. Set at `feature-init`, recorded in
  134. `feature.md`, constrained project-wide by `.engineer/manifest.yml`'s `autonomy.allowed_levels`,
  135. tightened for sensitive paths (security, billing) via path overrides.
  136. | Level | Behavior |
  137. |---|---|
  138. | `low` | Confirm before dispatching the next checkpoint. Review-everything mode. |
  139. | `medium` | Auto-dispatch, announced in one line. |
  140. | `high` | Auto-dispatch silently; report outcomes. "Agent, go cook." |
  141. Some gates ignore the dial: `plan` always asks the human to confirm the
  142. architecture, and **outward-facing writes** (pushing to `main`, opening or
  143. merging PRs, self-modifying agent config, writing to live systems) always
  144. require explicit authorization — even at `high`.
  145. <details>
  146. <summary><b>Worked example</b> — feature 015, idea to merge</summary>
  147. ```text
  148. # Session 1 — idea to spec
  149. $ /engineer.discuss
  150. [brainstorm: "add image upload to user profile"] → promote (autonomy: medium)
  151. Created features/015-image-upload/{feature.md, handoffs/, .build/} + branch
  152. $ /engineer.discover-acs
  153. [four-pass interview] → acs.md, 8 ACs in domain language
  154. [adviser + advocate panel] → 2 findings, 1 accepted
  155. Handoff → human review
  156. $ /engineer.atdd
  157. → spec.md (4 scenarios, standard Gherkin) + .build/spec.json + test pipeline
  158. # Session 2 — plan and build
  159. $ /engineer.plan
  160. [agent proposes architecture; human confirms; rest drafts]
  161. → plan.md (Charter Check: 0 deviations)
  162. $ /atdd:atdd-team
  163. [fresh agent per phase] → both test streams green
  164. [refine → arch-check → crap-analyzer → differential mutation]
  165. # Session 3 — wrap
  166. $ /engineer.session-summary
  167. → session-log.md, next-tasks: open the PR
  168. ```
  169. At every step the entry gate verifies the prior handoff, the branch check
  170. verifies you're on `image-upload`, and the breadcrumb shows where you are in the
  171. pipeline and on the roadmap.
  172. </details>
  173. ---
  174. ## The three plugins
  175. | Plugin | Purpose | Version |
  176. |---|---|---|
  177. | **[`engineer`](engineer/)** | The DAE methodology kit — 25 skills, 6 role agents, 26 guardrail scripts, the checkpoint pipeline, host mods | 0.40.2 |
  178. | **[`atdd`](./)** | ATDD workflow, team orchestration, differential mutation testing, portable Gherkin pipeline | 0.8.4 |
  179. | **[`crap-analyzer`](crap-analyzer/)** | Change Risk Anti-Pattern analysis on changed code | 0.1.1 |
  180. ### `engineer` — the methodology kit
  181. <details>
  182. <summary><b>All 25 skills</b></summary>
  183. | Skill | Role |
  184. |---|---|
  185. | `onboard` | Project bootstrap — charter, manifest, tracker (CP0) |
  186. | `discuss` | Upstream funnel — brainstorm; drop / park / promote |
  187. | `feature-init` | Produces `feature.md`, folder, branch, tracker entry (CP1.5) |
  188. | `prime-context` | Orient on a Ready feature before AC discovery |
  189. | `discover-acs` | AC discovery interview → `acs.md` (CP2) |
  190. | `atdd` | CP3 entry point — bridges into `atdd:atdd` |
  191. | `plan` | Architecture plan + Charter Check → `plan.md` (CP4) |
  192. | `refine` | Parallel reuse / quality / efficiency review (CP6) |
  193. | `arch-check` | Architecture fitness + CRAP analysis — layering, cycles, naming, size (CP7) |
  194. | `harden` | Runs the checks the refinement-advisor recommends: introversion, mutation, TLA+/Lean (CP8) |
  195. | `refinement-advisor` | Recommends which refine/verify/harden checks fit a diff; decides alone at high autonomy |
  196. | `tlaplus` | Model-check real code or a design with TLA+/TLC; counterexample → failing test |
  197. | `lean` | Prove an all-inputs invariant of real code in Lean 4; counterexample → failing test |
  198. | `run` | Coordinator: proposes the feature's agent graph, then drives CP2 → CP8 with only the front and back gates as human stops |
  199. | `fix` | Bug lifecycle, with a "why didn't we catch it?" gap analysis |
  200. | `reorient` | Mid-task re-anchoring after compaction or a long run |
  201. | `clarify` | Single-artifact ambiguity resolution |
  202. | `consistency-check` | Cross-artifact validation, read-only |
  203. | `feature-edit` | Intent-driven edits with downstream cascade |
  204. | `progress-log` | Handoffs → `progress.md` + tracker sync |
  205. | `session-summary` | Per-session `session-log.md` entry |
  206. | `post-merge` | Branch cleanup + state reconcile after a merge |
  207. | `next` | Session-start survey — what to pick up now |
  208. | `express` | One-pass lane for XS changes: test, code, gates, PR |
  209. | `prototype` | Build first, then derive the criteria from what converged |
  210. </details>
  211. <details>
  212. <summary><b>6 role agents</b></summary>
  213. The skills dispatch these as `engineer:<name>`. Each one enforces its own tool
  214. limits (the reviewers have no edit tools) and turn cap. A project overrides a
  215. role by copying the file into its own `.claude/agents/`.
  216. | Agent | Role | Dispatched by |
  217. |---|---|---|
  218. | `reviewer` | one refine lens (reuse / quality / efficiency), read-only | `refine` |
  219. | `panel-adviser` | constructive gap-finder, bounded one-shot | `discover-acs`, `plan` |
  220. | `panel-advocate` | adversarial claim-falsifier | `discover-acs`, `plan` |
  221. | `gauntlet-critic` | one falsifiable gap vs the bar, never edits | `atdd:atdd-team` (gauntlet) |
  222. | `formal-verifier` | one TLA+/Lean target, no PR | `harden` |
  223. | `verifier` | independent CP7 verdict, writes only the handoff | `refine` → CP7 |
  224. </details>
  225. Deeper detail lives in the repo, not here: `engineer/skills/*/SKILL.md` for each
  226. skill's workflow and exit contract, and `engineer/references/` for the shared
  227. contracts — handoff schema, progress indicators, review panel, model classes,
  228. host capabilities, ontology, parallelism, graph shapes, the coordinator, and more.
  229. ### `atdd` — Acceptance Test Driven Development
  230. > "Specs will be co-authored by the humans and the AI, but with final approval,
  231. > ferociously defended, by the humans." — Robert C. Martin
  232. Packages [Robert C. Martin's](https://en.wikipedia.org/wiki/Robert_C._Martin)
  233. approach to applying ATDD against agentic AI coding, as developed in
  234. [empire-2025](https://github.com/unclebob/empire-2025).
  235. **Two problems it solves.** Without acceptance tests anchoring behavior, an agent
  236. "willy-nilly plops code around" and writes unit tests that pass without verifying
  237. anything worthwhile. And left alone, agents fill Given/When/Then with class
  238. names, endpoints, and table names instead of domain language.
  239. ```shell
  240. /atdd:atdd Add user authentication with email and password
  241. /atdd:spec-check # audit specs for implementation leakage
  242. /atdd:mutate # verify the tests actually catch bugs
  243. /atdd:kill-mutants # write tests targeting survivors
  244. ```
  245. **The Golden Rule:** specs describe *what* the system does, never *how*.
  246. | ❌ Implementation leakage | ✅ Domain language |
  247. |---|---|
  248. | `Given the UserService has an empty userRepository` | `Given there are no registered users` |
  249. | `When a POST is sent to /api/users with JSON body` | `When a user registers with email "bob@example.com"` |
  250. | `Then the database contains 1 row in users` | `Then there is 1 registered user` |
  251. <details>
  252. <summary><b>The loop, and what a spec looks like</b></summary>
  253. ```
  254. 1. Write Given/When/Then specs — natural language, domain only
  255. 2. Generate the test pipeline (parser → IR → test generator),
  256. which has deep knowledge of your codebase internals
  257. 3. Run acceptance tests → they FAIL (red)
  258. 4. Implement with TDD until BOTH streams pass
  259. 5. Review specs for implementation leakage
  260. 6. Mutation testing → verify the tests actually catch bugs
  261. 7. Next feature, back to 1
  262. ```
  263. Specs are **standard Gherkin** in `spec.md`:
  264. ```gherkin
  265. Feature: User registration
  266. Scenario: User can register with email and password
  267. Given no registered users
  268. When a user registers with email "bob@example.com" and password "secret123"
  269. Then there is 1 registered user
  270. And the user "bob@example.com" can log in
  271. ```
  272. Migrating from the legacy `;=== .txt` format? Run
  273. `dae_gherkin_convert.py specs/feature.txt features/NNN-slug/spec.md` from the
  274. `engineer` plugin's `scripts/`. The `.txt` format is deprecated.
  275. </details>
  276. **Three validation layers**, each answering a different question:
  277. | Layer | Asks |
  278. |---|---|
  279. | Acceptance tests | **WHAT** — does the external behavior match the contract? |
  280. | Unit tests | **HOW** — is the internal structure right? |
  281. | Mutation testing | **REAL?** — do those tests actually catch bugs? |
  282. **Differential mutation testing** keeps layer 3 affordable: `dae_mutmap.py`
  283. maintains a committed manifest keyed by function, and re-mutates one only when
  284. its code, its covering tests, or the operator set changed. The hash triple makes
  285. the cache safe to share across CI, fresh clones, and every developer.
  286. <details>
  287. <summary><b>atdd plugin components</b></summary>
  288. | Component | Name | Purpose |
  289. |---|---|---|
  290. | Skill | `atdd` | 7-step workflow: specs → pipeline → red/green → iterate |
  291. | Skill | `atdd-team` | Fresh-per-phase agent team across six phases |
  292. | Skill | `atdd-mutate` | Mutation testing with differential re-runs |
  293. | Agent | `spec-guardian` | Catches implementation leakage in Given/When/Then |
  294. | Agent | `pipeline-builder` | Generates a bespoke parser → IR → test generator |
  295. | Hook | PreToolUse | Warns when writing code without acceptance specs |
  296. | Hook | Stop | Reminds you to verify both test streams |
  297. The generated pipeline is **not** Cucumber — "a strange hybrid of Cucumber and
  298. the test fixtures" (Uncle Bob). The parser/generator has deep knowledge of your
  299. system's internals and emits complete, runnable tests. No manual fixture code.
  300. </details>
  301. ### `crap-analyzer` — change risk
  302. Change Risk Anti-Pattern analysis over changed code: complexity × lack of
  303. coverage, scoped to a diff. Multi-language. Part of Checkpoint 7 alongside
  304. `arch-check`.
  305. ---
  306. ## Host independence
  307. DAE is a **methodology**, not a set of host features wearing a methodology's
  308. name. The pipeline, the checkpoint contract, the artifact schemas, and the
  309. `dae_*.py` guardrails are host-independent by construction — stdlib-only Python 3
  310. with no dependencies, precisely so that stays true.
  311. What *is* host-specific is the mechanism each capability is reached through. The
  312. skills name Claude Code's mechanisms directly ("dispatch via the Agent tool")
  313. because that's the host they run on today — but those names are **bindings, not
  314. the contract**. `engineer/references/host-capabilities.md` holds the seam:
  315. | | Capabilities |
  316. |---|---|
  317. | **Required** | dispatch a fresh agent · filesystem · script execution |
  318. | **Optional** | progress surface · structured ask · orchestration · isolation · remote execution · peer messaging · tool channels · rendered views · host hooks |
  319. Every optional capability has a specified degradation, so a host that lacks one
  320. loses a convenience, never the methodology. **Porting is editing that table's
  321. binding column**, plus the plugin-root path prefix and the host hook examples.
  322. The same discipline applies to models: `engineer/references/model-classes.md`
  323. names capability *classes* — `economy` / `inherit` / `frontier` — rather than
  324. product names, which get deprecated, and resolves them against the host's live
  325. model list at dispatch time.
  326. On Claude Code builds with function hooks, `engineer/hooks/register.tsx` adds
  327. the **engineer mods**: a progress sync that runs after every handoff write,
  328. guards that deny what the docs already forbid (frontier on a loop, an uncapped
  329. loop, unconfirmed pushes and PRs, a verifier editing code), a pipeline band
  330. above the prompt, a `/dae` pane and status line, a cross-session cost ledger,
  331. and a role re-anchor after compaction. Without them the pipeline runs as written.
  332. Optional capabilities are used when present and never depended on. A rendered
  333. board is a better answer to "where are we" than four lines of breadcrumb, so DAE
  334. offers one where the host can publish views — and always emits the terminal text
  335. regardless.
  336. ---
  337. ## Why not vibe coding
  338. **Vibe coding** is prompting loosely — *"build me a thing that does X"* —
  339. accepting what comes back, running it, patching when something feels off. No
  340. charter, no behavior contract, no verification gates. Fast at first, brittle
  341. over time: the codebase drifts, tests pass without proving anything, regressions
  342. surface when users find them.
  343. | | Vibe coding | DAE |
  344. |---|---|---|
  345. | **Architecture** | emerges from prompts | engineered upfront; `CHARTER.md` enforced by `arch-check` |
  346. | **Behavior contract** | "whatever the agent built" | ACs + Gherkin, human-approved, leakage-checked |
  347. | **Verification** | run it and see | two test streams + change-risk + mutation testing |
  348. | **Gates** | none | handoff-as-gate, branch hygiene, ontology, exit criteria |
  349. | **Refactoring safety** | tests may not catch regressions | mutation-tested suite = *semantic firewall* |
  350. | **Autonomy** | implicit, drifts | explicit per feature, manifest-constrained |
  351. | **Discipline lives in** | a prompt (and erodes) | tools the agent can't argue with |
  352. | **Pace** | fast initially | steady, sustainable |
  353. Shipping something quick and disposable? Vibe coding is fine. Building something
  354. you intend to maintain — with agents helping without eroding what they touch?
  355. That's what this is for.
  356. **The headline outcome is semantic stability.** ATDD plus mutation testing form a
  357. *semantic firewall*: code can be refactored, extended, or rewritten by agents
  358. without the system's intended behavior drifting.
  359. ### Who it's for
  360. **Software engineers.** DAE assumes you can read a `plan.md` and judge whether
  361. the architecture is sound; read a Gherkin spec and tell whether it captures
  362. intent; know when a charter rule should be enforced versus amended.
  363. **Not for non-programmers.** "Build an app without code" tools target a different
  364. audience and a different problem. The decisions DAE puts in front of you —
  365. architecture, behavior contracts, charter rules, verification thresholds,
  366. autonomy levels — are engineering decisions that need engineering judgment.
  367. ### Background & influences
  368. Programming has always climbed the abstraction ladder: front-panel switches →
  369. punch cards → assembly → high-level languages → managed runtimes → and now,
  370. with capable LLMs, **specification and behavior description as the next rung**.
  371. At every step the rung below fades from daily concern. Nobody hand-writes
  372. opcodes; nobody audits the assembly a compiler emits.
  373. **What never shifts is engineering discipline.** Compiler output earned trust
  374. because the compiler was rigorous *and the inputs were checked*. AI-generated
  375. code earns it the same way: rigorous input artifacts (charter, ACs, specs,
  376. plans) and checked output (two test streams, mutation testing, architecture
  377. fitness, change risk, duplicate and cycle detection). Change the artifact you
  378. author but stop checking the output, and you don't get speed — you get a faster
  379. path to a brittle system.
  380. DAE synthesizes four sources:
  381. | Source | What DAE takes from it |
  382. |---|---|
  383. | **ATDD** (XP / FIT / Fitnesse lineage — Kent Beck, Ward Cunningham, others) | Acceptance tests as a behavior contract. Uncle Bob's [empire-2025](https://github.com/unclebob/empire-2025) showed its particular power as a constraint on *agentic* development — two test streams the agent can't talk past, plus mutation testing as the test-quality firewall. |
  384. | **[Speckit](https://github.com/github/spec-kit)** | Specification is **iterative and layered**, not a one-shot document. Each feature evolves through progressively-sharper specs, each approved before the next. |
  385. | **[Acceptance Pipeline Specification](https://github.com/unclebob/Acceptance-Pipeline-Specification)** (Uncle Bob, 2026) | Portable pipeline: Gherkin → JSON IR → generated tests → runner, with mutation as an IR-level sidecar. |
  386. | **The host's stock `/simplify`** | The three-lens parallel review pattern (Reuse / Quality / Efficiency). DAE's `refine` adds charter validation of every proposal and graceful breaking-change classification. |
  387. Two further debts to Uncle Bob's public writing on ATDD, SDD, and AI-assisted
  388. development: the **swarm-failure observations** that drove DAE's
  389. deterministic-guardrail philosophy, and the **differential-mutation post** that
  390. shaped `dae_mutmap.py`.
  391. DAE's own additions: the Ready contract, autonomy levels, verification
  392. independence, the handoff / exit-criteria contract, the artifact ontology, the
  393. review panel, and the deterministic `dae_*.py` guardrails.
  394. This marketplace contains no code from empire-2025 or other upstream projects —
  395. it adapts the methodology.
  396. ---
  397. ## Repo layout
  398. ```
  399. .
  400. ├── .claude-plugin/ # marketplace + atdd plugin manifests
  401. ├── agents/ commands/ # atdd plugin agents and commands
  402. ├── hooks/ references/ # atdd plugin hooks and references
  403. ├── skills/ # atdd plugin skills (atdd, atdd-team, atdd-mutate)
  404. │
  405. ├── engineer/ # the DAE methodology kit
  406. │ ├── agents/ # 6 role agents (reviewer, panel-adviser/advocate,
  407. │ │ # gauntlet-critic, formal-verifier, verifier)
  408. │ ├── references/ # shared contracts — handoff, ontology, panel,
  409. │ │ # model classes, host capabilities, parallelism,
  410. │ │ # graph shapes, coordinator
  411. │ ├── scripts/ # dae_*.py guardrails + their unit tests
  412. │ ├── skills/ # the 25 engineer skills
  413. │ ├── examples/ # optional host hook configs
  414. │ └── hooks/ tests/ # engineer mods (function hooks) + their tests
  415. │
  416. └── crap-analyzer/ # change-risk analysis plugin
  417. ```
  418. ## Contributing
  419. Issues and PRs welcome on
  420. [GitHub](https://github.com/swingerman/engineer).
  421. ## License
  422. [MIT](LICENSE)

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.