Appendix FWhat does the QMS plugin do?

Chapter 06 says that a plugin set up the quality system and tells every BMAD workflow to load it. This appendix opens that plugin: what it is for, how it works, how it got there, and how it is tested. It is published, and anyone can read it.

Status, 3 November 2026

Version 1.0.1 is published at github.com/jouleco-fr/bmad-samd-qms, under the MIT licence, with its tests. Open: a check in the product's own build that the wiring still holds (OPEN-105), and the improvements ranked at the end. Numbers in the form OPEN-nnn are entries in the project's register of open items, part of its quality system (chapter 06).

What is it for?

An AI developer follows the rules it is given, when it is given them. The plugin's purpose is to make good practice the default path: every time a BMAD workflow starts, whether it writes a requirement, a story, code or a review, it loads the quality system's rules first. The Definition of Done, the constraints register, the traceability rule and the risk and software registers are present at every step, without anyone having to remember to supply them.

That makes the plugin a critical part of the method. It is also a simple one. It holds no model of its own, runs no service, and decides nothing. It is closer to a pocket calculator than to a scientific one: it asks about ten questions, lays out a folder of documents, and writes, for each workflow, which of those documents it must read.

How does it work?

Part What it does Size
A setup skill, run once with /qms-init asks about ten questions: the device's name, its classes under the US and EU rules and under IEC 62304, the markets, whether it handles health data about 100 lines of instructions
17 templates become the qms/ folder: Definition of Done, constraints register, registers of risks, software and open items, the regulatory files 17 Markdown files
Four scripts fill in the templates from the answers, register the module with BMAD, and write the wiring 926 lines of Python
A wiring list names, for each of nine workflows, the documents it loads one short file
An update skill brings newer templates in without touching edited documents about 20 lines

The quality records it creates live as text, next to the code, under version control: chapter 06 explains why that matters for an AI that reads files. The plugin only sets them up and wires them in; what goes into them is the team's work.

An extract of the wiring list, and the file it produces
# assets/wiring.toml: which QMS documents each BMAD workflow loads
[skills.bmad-dev-story]
facts = ["qms/definition-of-done.md", "qms/constraints-register.md",
         "qms/soup-register.md", "qms/risk/risk-register.md"]
# _bmad/custom/bmad-dev-story.toml, written by the plugin, read by BMAD
[workflow]
persistent_facts = [
  "file:{project-root}/qms/definition-of-done.md",
  "file:{project-root}/qms/constraints-register.md",
  "file:{project-root}/qms/soup-register.md",
  "file:{project-root}/qms/risk/risk-register.md",
]

How did it get there?

The first version, on 31 July, wired the workflows through instructions telling Claude which settings to write, and where. They named the wrong file, and for ten weeks no workflow loaded the quality system automatically. On 17 October, the audits run by a person found it, along with a second slip, re-runs that overwrote edited documents; chapter 07 tells both. The instructions were corrected the same day.

What is new since is that the wiring became code. On 2 November, the instructions were replaced by a script of 77 lines that reads the wiring list, writes the files, and refuses to overwrite one it did not write. Seven tests now run the plugin on a throw-away project. The one that matters most calls BMAD's own resolver, the piece of BMAD that decides what a workflow loads, and checks that every wired workflow gets every document, and that each document exists. That test would have caught the ten-week failure on its first run. All seven pass against BMAD 6.10.0. Version 1.0.0 was published on 3 November, under the MIT licence, by Jouleco. Version 1.0.1 followed the same day, after a test of the documented installation found that it could not work.

How do you use it?

In a project where BMAD is installed:

claude plugin marketplace add jouleco-fr/bmad-samd-qms
claude plugin install bmad-samd-qms@jouleco

Then, in Claude Code, run /qms-init: it asks its questions, lays out qms/ and wires the workflows. To check that the wiring works with your own BMAD installation, run the plugin's tests against it, from a copy of the repository:

BMAD_PROJECT=/path/to/your/project python3 -m unittest discover -s tests -v

The documents it creates are a starting point. They give the quality system its shape; filling them in is the team's work.

What does it not do?

It does not make software compliant. The templates give a quality system its shape, and filling it in, keeping it current and having it reviewed remain the team's work. Nor does it check that the rules are followed: it makes sure they are read. The checks that the rules hold are elsewhere, in the build and in the audits a person runs (chapter 07).

What did I learn?

Claude and BMAD contributed in two ways. A small plugin, built with Claude, was enough to put the quality system in front of every workflow; nothing more elaborate was needed. And BMAD's design made it possible: one file per workflow, read by a resolver that can be called from a test.

About the method, each finding points at how the work was done:

Finding What it says about the method
As instructions, it could not be tested The step could not be checked by a test, so it never was
Turned into a script, it was tested in a day, through BMAD's own resolver As a short script, the layer that enforces good practice became something a test can prove
The plugin overwrote edited documents A tool I built was not held to the Definition of Done I held the product to

What would I change?

Four proposals follow, the most useful first, each with what a later check would measure.

Rank Improvement Why at this rank Measure
1 The product's own build runs BMAD's resolver for every wired workflow and fails if a QMS document is missing (OPEN-105) The plugin's tests prove the plugin; only the product's build can prove the wiring still holds after a BMAD upgrade Builds that check the wiring
2 The plugin's tests run on every change, on the public repository Anyone can see them pass Test runs per release
3 Any rule that must hold every time lives in a script or a check, with the instruction as its explanation It removes the cause of the ten-week failure, for every rule Rules enforced by code, against rules listed
4 The update skill gets the same tests as the setup It is the other half of the plugin, and the half most likely to overwrite something Tests of the update

For your own project

  • Put the rules where the agent reads them, at every step, whatever method surrounds it.
  • Make the wiring that delivers them code, and keep instructions for what may vary.
  • Test that wiring through the framework's own mechanism, the way the agent will see it, and run that test in your build.

Where does this leave the project?

At its gate, the project has this much in place: the plugin that puts the quality system in front of every workflow is published, small, and tested where it once failed. What it cannot do is prove that the product's own workflows still load it tomorrow. That check, made by the product's own build, is the first of these proposals; it is recorded as open item OPEN-105. A later version of this appendix will say which proposals were taken.