refactor(framework): SDLC anti-slop templates + strict review contract

README.md

@@ -26,7 +26,7 @@
 [![CI](https://github.com/ai-driven-dev/framework/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/ai-driven-dev/framework/actions/workflows/ci.yml)
 [![Made in France](https://img.shields.io/badge/made%20in-France-0055A4?labelColor=EF4135)](https://www.ai-driven-dev.fr/)
 
-<p>🗺️ <a href="https://github.com/orgs/ai-driven-dev/projects/8/views/1"><b>Live roadmap</b></a> — what's shipping Now / Next / Later</p>
+<p>🗺️ <a href="https://github.com/orgs/ai-driven-dev/projects/8"><b>Live roadmap</b></a> — what's shipping Now / Next / Later</p>
 
 </div>
 
@@ -238,7 +238,7 @@ Task-oriented how-to sheets. **[Browse all recipes →](recipes/)**
 
 > ⭐ **Free & open-source (MIT), built by the AIDD community.** If AIDD saves you time, [**a star**](https://github.com/ai-driven-dev/framework/stargazers) genuinely helps the project grow and helps other developers find it.
 
-> Actively maintained — the [roadmap](https://github.com/orgs/ai-driven-dev/projects/8/views/1) is public; help shape what comes after.
+> Actively maintained — the [roadmap](https://github.com/orgs/ai-driven-dev/projects/8) is public; help shape what comes after.
 
 Got an idea or hit a bug? **[Open an issue](https://github.com/ai-driven-dev/framework/issues)** or **[start a discussion](https://github.com/ai-driven-dev/framework/discussions)**. For everything else, **[join the Discord](https://discord.gg/EWySJSpjWs)**.
 

aidd_docs/plans/2026_07_01-sdlc-anti-slop/phase-1.md

@@ -0,0 +1,30 @@
+---
+status: pending
+---
+
+# Instruction: Root rule, behavior over instructions
+
+Part of [`plan.md`](./plan.md).
+
+## Architecture projection
+
+```txt
+plugins/aidd-context/skills/04-skill-generate/references/
+  ✏️ skill-authoring.md   # add the Steinberger rule (new R)
+```
+
+## Tasks to do
+
+### `1)` Add the behavior-over-instructions rule
+
+> Codify the pivot as an authoring rule every generator reads.
+
+1. Add a new `R` to `skill-authoring.md`: an action describes the behavior and the qualify-if bar, never a slot-fill checklist. A template section states what qualifies it and omits when nothing does.
+2. State the anti-slop consequence in one line: an empty slot is omitted, never invented.
+3. Keep it inside the existing R-list numbering and voice; no new file.
+
+## Test acceptance criteria
+
+| Task | Acceptance criteria                                                                 |
+| ---- | ---------------------------------------------------------------------------------- |
+| 1    | `skill-authoring.md` carries a rule that says describe behavior + qualify-if/omit, and forbids inventing content for an empty section. |

aidd_docs/plans/2026_07_01-sdlc-anti-slop/phase-2.md

@@ -0,0 +1,31 @@
+---
+status: pending
+---
+
+# Instruction: Gates single-home + SDLC assert step
+
+Part of [`plan.md`](./plan.md).
+
+## Architecture projection
+
+```txt
+plugins/aidd-dev/skills/00-sdlc/
+  ✏️ SKILL.md   # insert an assert step between implement and review
+```
+
+## Tasks to do
+
+### `1)` Chain assert in the orchestrator
+
+> The gate must run once gates leave the plan.
+
+1. Add an assert step to the `00-sdlc` action table, delegating to `aidd-dev:03-assert`, between `implement` and `review`.
+2. Update the run order and the iterate loop so a failed assert loops back to implement.
+3. Confirm no SDLC template or action restates build/test/typecheck commands; those stay in `coding-assertions.md`.
+
+## Test acceptance criteria
+
+| Task | Acceptance criteria                                                        |
+| ---- | ------------------------------------------------------------------------- |
+| 1    | `00-sdlc` runs implement → assert → review; a failed assert returns to implement. |
+| 1    | No SDLC skill file lists a build or test command; the gate reads `coding-assertions.md`. |

aidd_docs/plans/2026_07_01-sdlc-anti-slop/phase-3.md

@@ -0,0 +1,32 @@
+---
+status: pending
+---
+
+# Instruction: Spec done-when as observable conditions
+
+Part of [`plan.md`](./plan.md).
+
+## Architecture projection
+
+```txt
+plugins/aidd-pm/skills/04-spec/
+  ✏️ assets/spec-template.md   # done-when = observable condition, qualify-if guidance
+  ✏️ actions/01-build.md       # behavior, not slot-fill
+```
+
+## Tasks to do
+
+### `1)` Discipline done-when
+
+> One observable condition per line, no user-story scaffolding.
+
+1. Rewrite the Done-when block guidance: each item is an observable condition (what a user or system can be seen doing), not a command and not a feeling.
+2. Confirm the plan references the spec done-when rather than recopying it (contract owns it).
+3. Update `01-build.md` so it describes the qualify bar per section and omits an empty one, per the phase-1 rule.
+
+## Test acceptance criteria
+
+| Task | Acceptance criteria                                                            |
+| ---- | ----------------------------------------------------------------------------- |
+| 1    | Done-when items read as observable conditions; the template shows no command as a done-when. |
+| 1    | `01-build.md` instructs qualify-if/omit, carrying no fill-every-slot wording. |

aidd_docs/plans/2026_07_01-sdlc-anti-slop/phase-4.md

@@ -0,0 +1,43 @@
+---
+status: pending
+---
+
+# Instruction: Plan + phases anti-slop
+
+Part of [`plan.md`](./plan.md).
+
+## Architecture projection
+
+```txt
+plugins/aidd-dev/skills/01-plan/
+  ✏️ assets/plan-template.md    # decisions = magnitude, resources = URLs/files
+  ✏️ assets/phase-template.md   # wireframe omit-guard, acceptance = observable, drop header redirect
+  ✏️ actions/04-plan.md         # qualify-if/omit behavior
+  ✏️ actions/03-wireframe.md    # only when the phase has UI
+```
+
+## Tasks to do
+
+### `1)` Qualify each plan section
+
+> Every table earns its rows or omits.
+
+1. Decisions: qualify bar = "you would regret reversing it" (architecture magnitude). Small choices are omitted, not recorded.
+2. Resources: external URLs consulted, in the plan; modified files belong to the phase, not the plan resources table.
+3. Phase acceptance criteria: observable behavior only; a build/test command is a gate, never an acceptance criterion.
+
+### `2)` Trim the phase
+
+> Cut what no reader uses.
+
+1. Wireframe section: keep the `omit when no UI` guard and make `03-wireframe` run only for a UI phase.
+2. Drop the redundant "Part of plan.md" redirect if it carries no navigation value, or justify keeping it in one line.
+3. Rewrite `04-plan.md` to the qualify-if/omit behavior from phase 1.
+
+## Test acceptance criteria
+
+| Task | Acceptance criteria                                                              |
+| ---- | ------------------------------------------------------------------------------- |
+| 1    | Templates state the qualify bar for decisions, resources, and acceptance criteria. |
+| 1    | Acceptance-criteria guidance forbids a bare command as a criterion.             |
+| 2    | A no-UI phase produces no Wireframe section; `03-wireframe` self-skips without UI. |

aidd_docs/plans/2026_07_01-sdlc-anti-slop/phase-5.md

@@ -0,0 +1,41 @@
+---
+status: pending
+---
+
+# Instruction: Review redesign, trace phases as checkboxes
+
+Part of [`plan.md`](./plan.md).
+
+## Architecture projection
+
+```txt
+plugins/aidd-dev/skills/05-review/
+  ✏️ assets/review-template.md      # phases as checkboxes, verification line, no prose/follow-up
+  ✏️ actions/02-review-functional.md # trace the plan's phases, not a free criterion table
+  ✏️ SKILL.md                        # point sections at the new template shape
+```
+
+## Tasks to do
+
+### `1)` Rebuild the review template
+
+> A skimmable gate a human reads in one pass.
+
+1. Structure the report around the plan's phases: one category per phase, each acceptance criterion a checked or unchecked box.
+2. End with a verification line: percent verified, the files checked, and a fix / not-applicable / fixed status per unchecked item.
+3. Delete the prose blocks and the Follow-up section; the verdict line and the boxes carry the signal.
+
+### `2)` Point the actions at it
+
+> The functional axis follows the plan.
+
+1. Rewrite `02-review-functional.md` to trace the plan's phases and their acceptance criteria, not an ad-hoc criterion list.
+2. Update `SKILL.md` section wording to match the new template.
+
+## Test acceptance criteria
+
+| Task | Acceptance criteria                                                                     |
+| ---- | -------------------------------------------------------------------------------------- |
+| 1    | `review.md` shows one category per plan phase with checked/unchecked boxes and a final verification line. |
+| 1    | The template carries no Follow-up section and no prose paragraph.                        |
+| 2    | `02-review-functional.md` traces the plan's phases; a review of a phased plan lists every phase. |

aidd_docs/plans/2026_07_01-sdlc-anti-slop/plan.md

@@ -0,0 +1,63 @@
+---
+objective: "SDLC artifacts stop emitting slop: every template section states what qualifies it and omits when nothing does, gates live only in /assert, the review traces the plan's phases as checkboxes."
+status: pending
+---
+
+# Plan: SDLC anti-slop hardening
+
+## Overview
+
+| Field      | Value                                                                                  |
+| ---------- | -------------------------------------------------------------------------------------- |
+| **Goal**   | Cut the telling-what-to-do, tighten the output contract, so artifacts stay skimmable.  |
+| **Source** | Brainstorm 2026-06-30 (Alex's SDLC run: weak decisions, fake acceptance criteria, useless wireframe, unreadable review). |
+
+## Pivot
+
+Two axes were conflated. Separate them:
+
+- **How the agent works** (process, steps) => loosen, cut. This is Steinberger: describe the behavior, not the steps.
+- **What it emits** (templates, assets) => constrain hard.
+
+"Cut more" means cut the instructions, not the structure. The root cause of every slop item: a template with empty slots that the agent fills anyway. Fix = each section states its qualify-if bar and omits when nothing meets it.
+
+## Phases
+
+| #   | Phase                                        | File                         |
+| --- | -------------------------------------------- | ---------------------------- |
+| 1   | Root rule: behavior over instructions        | [`phase-1.md`](./phase-1.md) |
+| 2   | Gates single-home + SDLC assert step         | [`phase-2.md`](./phase-2.md) |
+| 3   | Spec: done-when as observable conditions      | [`phase-3.md`](./phase-3.md) |
+| 4   | Plan + phases anti-slop                       | [`phase-4.md`](./phase-4.md) |
+| 5   | Review redesign: trace phases, checkboxes     | [`phase-5.md`](./phase-5.md) |
+
+## Resources
+
+| Source        | Verified                    |
+| ------------- | --------------------------- |
+| `plugins/aidd-context/skills/04-skill-generate/references/skill-authoring.md` | Rules live as R1..Rn here; every generator reads it. Home for the Steinberger rule. |
+| `plugins/aidd-dev/skills/03-assert/SKILL.md` | Already the gate: "returns a pass or fail verdict", fix-loop until green. Runs the project's coding assertions. |
+| `plugins/aidd-dev/skills/00-sdlc/SKILL.md` | Chains spec→plan→implement→review→ship. No assert step: gates would drop if stripped from the plan. |
+| `plugins/aidd-dev/skills/01-plan/assets/{plan,phase}-template.md` | Slot templates. `04-plan.md:17` already carries an omit idiom; phase wireframe carries `omit when no UI`. Inconsistent. |
+| `plugins/aidd-pm/skills/04-spec/assets/spec-template.md` | Done-when + optional-section suffix `(optional)` already present. |
+| `plugins/aidd-dev/skills/05-review/assets/review-template.md` | Prose + Follow-up section; functional axis traces criteria in a table, not the plan's phases. |
+| `aidd_docs/memory/coding-assertions.md` | Project's gate commands (build/test/typecheck) — the single home gates belong in. |
+
+## Decisions
+
+| Decision   | Why            |
+| ---------- | -------------- |
+| Steinberger rule lands in `skill-authoring.md`, not a new central "golden rules" doc | No golden-rules surface exists; every generator already reads this file, so the rule propagates for free. |
+| Gates leave the plan for `/assert` + `coding-assertions.md` | One home per fact; the plan becomes 100% behavioral, gates stay mechanical and single-sourced. |
+| `00-sdlc` gains an assert step between implement and review | Stripping gates from the plan drops them unless the orchestrator runs `/assert` explicitly. |
+| Reuse the existing `<!-- omit when ... -->` idiom for optional sections | The pattern already exists (phase wireframe); inventing HTML-template machinery would be churn. |
+
+## Spec done-when → phase coverage
+
+| Done-when (observable) | Phase |
+| ---------------------- | ----- |
+| A rule in `skill-authoring.md` states "describe behavior + qualify-if/omit, never slot-fill" | 1 |
+| `00-sdlc` runs `/assert` before review; no template restates build/test commands | 2 |
+| Spec done-when items are observable conditions, no user-story scaffolding required | 3 |
+| Plan decisions are magnitude-only; resources are URLs/files; wireframe omits without UI; no phase-header redirect | 4 |
+| `review.md` mirrors the plan's phases as checked/unchecked boxes, ends with a verification line, carries no prose dump or Follow-up | 5 |

plugins/aidd-context/skills/04-skill-generate/references/skill-authoring.md

@@ -19,7 +19,7 @@ The contract every generated skill must satisfy. These rules govern the CLIENT s
 - **R6.** Zero duplication. One fact, one home. Actions cite a shared file via `@<path>` instead of restating it.
 - **R7.** `references/` = documents to READ and apply in place. `assets/` = files to COPY, INJECT, or fill in per run. A template, checklist, or form is an asset, not a reference, because each run instantiates it.
 - **R8.** Every action follows the action anatomy (below) and carries a `## Test`.
-- **R9.** Omit any optional section that would be empty. Never write a placeholder like `## External data` + `None.`.
+- **R9.** A section earns its content or is omitted. State each section's qualify bar and describe the behavior it captures, not a slot to fill. An entry that fails the bar is dropped, never invented to occupy the row. Never write `## External data` + `None.`, nor mint a decision, criterion, or resource just because the template offers it. A template's section set is closed: an instance fills or omits the defined sections and never adds, renames, or reorders one.
 - **R10.** Generated skills are English only (frontmatter, body, actions, references, assets), regardless of conversation language.
 - **R11.** One idea per sentence. Split a sentence that runs past one line. Exceptions: the single-line `description` and table rows.
 - **R12.** One file = one artifact. A reference or asset holds a single coherent thing: one checklist, one template, one criteria set. When a file accumulates several independently reusable artifacts, split them so each is cited and reused alone. Prefer this split over bundling, even when the combined file is short.

plugins/aidd-dev/agents/checker.md

@@ -15,7 +15,8 @@ You are the checker. Your job is to judge finished work against its validator an
 - Run the checklist on every code or diff, leaving no item unchecked.
 - Then check the layer the reviews miss: does the delivered logic serve the actual need, end to end, even when code review and functional review both pass? Name any gap between intent and result.
 - Demand command output or file evidence, never bare claims. Lean strict: a false alarm costs less than a missed defect.
-- Return your verdict, findings, and score to whoever invoked you. Hold yourself accountable for whatever you pass.
+- When a review skill fits the work, run it and let it write its report; that report is your deliverable and your judgment is what fills it. Never hand-write a parallel prose review beside it.
+- Return your verdict, findings, and score on top. Hold yourself accountable for whatever you pass.
 
 # Checklist
 

plugins/aidd-dev/skills/00-sdlc/SKILL.md

@@ -14,7 +14,7 @@ Take a request from idea to shipped code, delegating every step. Interactive by
 | --- | ----------- | ------------------------------------- | --------------------------------------- |
 | 01  | `spec`      | Consolidate sources into the contract | a spec capability                       |
 | 02  | `plan`      | Produce the plan file                 | self, via `aidd-dev:01-plan`            |
-| 03  | `implement` | Build the plan's code                 | `executor`, via `aidd-dev:02-implement` |
+| 03  | `implement` | Build the plan's code, gating on the assertions | `executor`, via `aidd-dev:02-implement` |
 | 04  | `review`    | Verdict `ship` or `iterate`           | `checker`, via `aidd-dev:05-review`     |
 | 05  | `ship`      | Open the change request               | a commit and change-request capability  |
 

plugins/aidd-dev/skills/00-sdlc/actions/04-review.md

@@ -8,12 +8,12 @@ The working diff or paths produced by `03`, the validator (the plan path and acc
 
 ## Output
 
-A `ship` or `iterate` verdict with the reviewed items, the findings, the completion and quality scores, and the reviewed `HEAD` SHA (the commit the checker actually saw). The plan reaches `status: reviewed` on ship, and stays `implemented` on iterate.
+A `ship` or `iterate` verdict with the reviewed items, findings, completion and quality scores, and the reviewed `HEAD` SHA (the commit the checker saw), from `05-review`. The plan reaches `status: reviewed` on ship, and stays `implemented` on iterate.
 
 ## Process
 
 1. **Capture.** Record the current `HEAD` sha as the reviewed SHA. This is the exact code the checker judges, and the anchor `05-ship` checks against.
-2. **Spawn.** Spawn the `checker` agent with the inputs above. Brief it to run `aidd-dev:05-review`, code, functional, and relevancy, on that diff, and return its verdict.
+2. **Spawn.** Spawn the `checker` agent with the inputs above. Brief it to run `aidd-dev:05-review` on that diff, let that skill write and own its report, and return the verdict and findings.
 3. **Map.** When every check passes, the verdict is `ship`. On any blocking finding, the verdict is `iterate`.
 4. **Mark.** On `ship`, set the plan frontmatter `status: reviewed` and commit it. Carry the reviewed SHA in the verdict. On `iterate`, leave the plan `implemented`: the loop fixes the diff, not the plan.
 5. **Iterate.** On `iterate`, return the findings as the fix list for `03`. The next `04` re-captures the SHA on the fixed diff; ship is reached only when a review of the current diff passes.

plugins/aidd-dev/skills/01-plan/actions/04-plan.md

@@ -14,7 +14,7 @@ A feature folder, always at `aidd_docs/tasks/<yyyy_mm>/<yyyy_mm_dd>_<feature-slu
 
 1. **Phases.** Break the work into phases, each a coherent unit of work that ships and verifies on its own, sized for one executor pass. Let the work decide how many.
 2. **Folder.** Reuse the feature folder the source already lives in, or create one.
-3. **Fill.** Scaffold from the templates and fill only the sections they define, omitting any that stays empty (resources when nothing was consulted). Slice the projection across the phases, list the consulted resources in the resources table, and embed any wireframe in its phase's Wireframe section.
+3. **Fill.** Scaffold from the templates, filling only what qualifies and omitting any section whose bar nothing meets. Slice the projection across the phases. Resources lists external sources only, not code files. Decisions holds architecture-magnitude choices only. Keep a phase's Wireframe only when that phase ships UI.
 4. **Show.** Display the written paths.
 5. **Review.** Show the complete plan and its phases with a confidence score (0 to 10, ✓ reasons and ✗ risks). Take feedback, revise the files, and re-show until approved. The score is never written to the plan.