Skip to content
Back to search

assurance-kit

The Automotive Safety & Security Assurance Kit for Claude Code: Automotive SPICE, ISO 26262 and ISO/SAE 21434 for automotive ECU software.

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

Its scripts were only partly scanned.

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/Lieubk/automotive-safety-security-assurance-kit 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/Lieubk/automotive-safety-security-assurance-kit'

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/lieubk--automotive-safety-security-assurance-kit/badge.svg)](/listings/lieubk--automotive-safety-security-assurance-kit)

HTML

<a href="/listings/lieubk--automotive-safety-security-assurance-kit"><img src="/api/listings/lieubk--automotive-safety-security-assurance-kit/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

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

Clone the repository and look at the worked example first:

git clone https://github.com/Lieubk/automotive-safety-security-assurance-kit.git
cd automotive-safety-security-assurance-kit
python tools/traceability.py --project examples/power-window check
python tools/traceability.py --project examples/power-window practices
python tools/traceability.py --project examples/power-window impact SWR-0003
python examples/power-window/tests/unit/run_tests.py
python examples/power-window/tests/integration/run_tests.py
python examples/power-window/tests/qualification/run_tests.py

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 · 14 lines
  1. {
  2. "name": "assurance-kit",
  3. "description": "The Automotive Safety & Security Assurance Kit for Claude Code: Automotive SPICE, ISO 26262 and ISO/SAE 21434 for automotive ECU software.",
  4. "owner": {
  5. "name": "lieund"
  6. },
  7. "plugins": [
  8. {
  9. "name": "assurance-kit",
  10. "source": "./",
  11. "description": "Process, safety and security assurance for automotive ECU software: skills, agents, hooks and a trace engine for Automotive SPICE 3.1 (and 4.0 from its draft), ISO 26262 and ISO/SAE 21434, with engineering items as text files in your repository."
  12. }
  13. ]
  14. }
README.md · README · 187 lines
  1. # Automotive Safety & Security Assurance Kit
  2. **Process, safety and security assurance for automotive ECU software.**
  3. A set of [Claude Code](https://claude.com/claude-code) skills, agents and hooks, plus
  4. deterministic tools, for developing automotive ECU software in line with Automotive
  5. SPICE 3.1 (and 4.0, from its draft), ISO 26262 and ISO/SAE 21434. Requirements, architecture, design, test cases and evidence live as text
  6. files in the repository - one item per file - and a trace engine checks them.
  7. The toolkit drafts and checks. People decide, review and are accountable.
  8. **New here?** The [user guide](docs/user-guide.md) walks through a project from the first
  9. session to a delivered release: setting the scope, the daily loop of drafting and review,
  10. tests and evidence, baselines and changes, safety, cybersecurity, documents, and what to
  11. do when the toolkit refuses something.
  12. ## At a glance
  13. | Scale | What it covers |
  14. |---|---|
  15. | **38** skills | one per process or task, from project scope to release: system and software engineering (SYS.2 to SYS.5, SWE.1 to SWE.6), project management, quality assurance, configuration, problem and change management, supplier monitoring, release, functional safety and cybersecurity |
  16. | **12** role agents | system engineer, software requirements engineer, software architect, software developer, unit verification engineer, software and system test engineers, safety engineer, cybersecurity engineer, project manager, configuration manager, and an independent reviewer |
  17. | **28** review checklists | the checks a review applies - by script, by an independent reviewer agent, or by a named person |
  18. | **55** item types, **24** link roles, **78** coverage rules | from stakeholder requirement to code, test, review, baseline and release, checked by a deterministic trace engine |
  19. | **32** processes, **265** base practices | Automotive SPICE 3.1, with evidence and open findings per base practice; Automotive SPICE 4.0 from its draft 3.991, **197** base practices mapped onto 3.1 |
  20. | **12** parts, **48** clauses, **669** requirement numbers | ISO 26262:2018 - a decision and its evidence per clause |
  21. | **41** subclauses, **118** requirement identifiers, **42** work products | ISO/SAE 21434:2021 - a decision and its evidence per subclause |
  22. | **40** document kinds, **4** formats | specifications, architecture and design descriptions, test specifications and reports, TARA, safety and cybersecurity plans and cases, project and quality reports - as HTML, PDF, Word or Excel, neutral or in the customer's template |
  23. | **6** exchange routes | ReqIF, AUTOSAR ARXML, Excel, and REST connectors to Polarion, codebeamer and Jama Connect |
  24. | **15** tools, over **9,000** lines of Python | trace engine, record writer, document generator, validators, exchange adapters |
  25. | **342** regression tests | trace engine, records, documents, exchange adapters and hooks |
  26. | **155** items, **31** documents, **345** pages | the worked example of a software supplier: a power window with anti-pinch protection at ASIL B |
  27. | **105** items | the worked example of a system supplier: a door control unit from the OEM's requirements through system architecture, bench integration and qualification, supplier, risks and vulnerability monitoring to a delivered release |
  28. **See what it produces:** [31 documents, 345 pages, generated from the worked example](examples/power-window/documents/) -
  29. requirements, architecture and design, test specifications and reports, traceability, TARA,
  30. safety and cybersecurity cases - as PDF, HTML, Word and Excel.
  31. ## Status
  32. First release, 0.1.0. Every process of the VDA scope of Automotive SPICE 3.1 has a skill -
  33. SYS.2 to SYS.5, SWE.1 to SWE.6, MAN.3, SUP.1, SUP.8 to SUP.10 and ACQ.4. Two worked examples
  34. run the processes end to end: a software supplier with ISO 26262 and ISO/SAE 21434 in scope
  35. (`examples/power-window`), and a system supplier from the OEM's requirements to a delivered
  36. release (`examples/door-control-unit`). The changes are listed in [CHANGELOG.md](CHANGELOG.md).
  37. | Area | State |
  38. |---|---|
  39. | Process catalog | 32 processes of Automotive SPICE 3.1 with base practices, work products and rating dependencies, 26 of them covered by evidence structures and rules (23 with skills) and the others in the catalog only; 32 processes of Automotive SPICE 4.0 built from the draft 3.991 (which its publisher marks as not for assessments), each base and generic practice mapped to the 3.1 practices whose evidence it reads. Identifiers and official names; descriptions in our own words |
  40. | Item schema | 55 item types, 24 link roles, 78 coverage rules, scope-aware |
  41. | Documents | 40 kinds - specifications, SAD, SDD, test specifications and reports with verdicts, traceability, review, release note, QA, problem, change, project, risk, supplier, TARA report and worksheet, cybersecurity plan and case - generated from the items as HTML, PDF, Word or Excel (`tools/document.py`), in a neutral style or the customer's Word template or Excel workbook, with commit, baseline and the items' hashes; DRAFT when items are not approved |
  42. | ISO 26262 | parts in scope per project; safety plan with a decision per clause and methods per table, hazardous events and safety goals, ASIL carried through requirements and design, safety analyses (FMEA, FTA, DFA), decomposition, tool evaluation, confirmation measures, safety case; `traceability.py safety`; the standard's tables are stated by the project, not copied |
  43. | ISO/SAE 21434 | clauses in scope per project; TARA (assets, damage and threat scenarios, attack paths, risk values from the project's matrix, treatment), goals and claims, concept, security relevance down to code and tests, vulnerability management, cybersecurity case and assessment records; `traceability.py tara` and `clauses` |
  44. | Trace engine | structure, links, coverage, stale approvals, suspect links, impact, traceability matrices, evidence per base practice, changes since a review, progress against the plan, integration steps and the builds and runs on them at software and system level, problems, quality assurance, observations per generic practice of level 2 |
  45. | Packaging | a Claude Code plugin (`assurance-kit`) with its own marketplace, installed into the repository of a project; or a copy of this repository |
  46. | Continuous integration | pipeline templates for projects (GitHub Actions, GitLab CI, `ci/`); the toolkit's own checks in `.github/workflows/toolkit.yml` |
  47. | Skills | project scoping and input registration; project management and risk management (MAN.3, MAN.5); SYS.2 to SYS.5 and SWE.1 to SWE.6; reviews and quality assurance; baselines, change requests and problem resolution; supplier monitoring; release; functional safety (safety plan, HARA, safety concept, safety analyses, component qualification and proven in use); cybersecurity (plan, TARA, concept, vulnerability management); documents; trace check, process gates and a mock assessment |
  48. | Hooks | imported inputs, final records and baselined items are protected; every written item is checked |
  49. | Out of scope | hardware development (ISO 26262 part 5) and the hardware-related clauses 8:13; organization-level requirements (ISO/SAE 21434 clause 5, ISO 26262-2 clauses 5 and 7, REU.2, capability level 3) - a project refers to the organization's evidence; motorcycles (ISO 26262 part 12). The catalogs list them; no rule or skill covers them |
  50. | Exchange | ReqIF import, comparison of a new version and export (`tools/reqif.py`); Excel requirements in and out and test results in (`tools/xlsx.py`); Polarion, codebeamer and Jama Connect over REST (`tools/alm.py`, written from their public interface descriptions, tested against a simulated server); AUTOSAR Classic models to architecture items and back to a comparison (`tools/arxml.py`) |
  51. | Not yet | Automotive SPICE 4.0 from its released text: the catalog follows the draft 3.991 until then, without the rating consistency rules; HWE, MLE and SUP.11 in the catalog only |
  52. ## What it does not do
  53. - It does not rate capability levels and is not an assessment. It shows evidence and
  54. gaps; assessors rate.
  55. - It does not replace qualified tools. It drives the compiler, test tool and analyser a
  56. project uses and records what they reported.
  57. - It does not reach hardware. Tests on a target or a test bench are specified, traced
  58. and recorded here, and executed there.
  59. - It does not approve anything. An item becomes approved through a review with a named
  60. person's verdict.
  61. ## Requirements
  62. - Claude Code
  63. - Python 3.10 or later on the PATH as `python` (or `python3`), with PyYAML
  64. (`python -m pip install pyyaml`); python-docx for Word and openpyxl for customer Excel
  65. workbooks are optional
  66. - Git
  67. - For the example: a C compiler (gcc, clang, or Visual Studio on Windows); gcc with gcov
  68. for coverage
  69. ## Models
  70. Each agent names the model its work needs, so that judgement gets the strongest model
  71. and routine work a cheaper one:
  72. | Agent or skill | Model | Effort |
  73. |---|---|---|
  74. | `aspice-reviewer`, `software-architect`, `system-engineer` | `opus` | high |
  75. | `software-requirements-engineer`, `software-developer` | `sonnet` | high |
  76. | `unit-verification-engineer`, `software-test-engineer`, `system-test-engineer`, `configuration-manager`, `project-manager` | `sonnet` | medium |
  77. | `/trace-check`, `/next-step` (run in a fork) | `haiku` | low, medium |
  78. | every other skill | the model of your session | your setting |
  79. The names are aliases. On the Anthropic API they resolve to the newest model of the
  80. family; on other providers they may resolve to an earlier version. To run every agent
  81. on one model instead, set `CLAUDE_CODE_SUBAGENT_MODEL` to that model and
  82. `CLAUDE_CODE_SUBAGENT_MODEL_FORCE` to `1` (Claude Code v2.1.257 or later), or change
  83. `model` in the agent's file under `.claude/agents/`. The reasons for each choice are in
  84. `.claude/docs/skill-authoring.md`, "Model and effort".
  85. ## Quick start
  86. Clone the repository and look at the worked example first:
  87. ```
  88. git clone https://github.com/Lieubk/automotive-safety-security-assurance-kit.git
  89. cd automotive-safety-security-assurance-kit
  90. python tools/traceability.py --project examples/power-window check
  91. python tools/traceability.py --project examples/power-window practices
  92. python tools/traceability.py --project examples/power-window impact SWR-0003
  93. python examples/power-window/tests/unit/run_tests.py
  94. python examples/power-window/tests/integration/run_tests.py
  95. python examples/power-window/tests/qualification/run_tests.py
  96. ```
  97. ## Install into your project
  98. The toolkit is a Claude Code plugin. Install it into the repository of your project; the
  99. items, records and `project.yaml` live there, the toolkit stays in the plugin.
  100. ```
  101. /plugin marketplace add Lieubk/automotive-safety-security-assurance-kit
  102. /plugin install assurance-kit@assurance-kit
  103. ```
  104. From a shell, `claude plugin marketplace add Lieubk/automotive-safety-security-assurance-kit`
  105. and `claude plugin install assurance-kit@assurance-kit --scope project` do the same and write
  106. the plugin into the project's `.claude/settings.json`, so that every member of the team is
  107. asked to install it.
  108. Then open Claude Code in your project and run `/aspice-start` (as a plugin skill also
  109. `/assurance-kit:aspice-start`). It asks who you are in the supply chain, what you were
  110. given, and which processes you are responsible for, and writes `project.yaml`. From there
  111. `/next-step` says what to do. A new session prints where the toolkit is installed and the
  112. working agreement; the tools run from your project folder as
  113. `python "<toolkit root>/tools/<script>.py"`. To be asked less often, allow the read-only
  114. ones in your project's `.claude/settings.json` with the path the session prints.
  115. Without the plugin you can still work in a copy of this repository: open it in Claude
  116. Code, and every skill, agent and hook is active there.
  117. ## How it is put together
  118. ```
  119. aspice/3.1/ process catalog and notes per process
  120. aspice/4.0/ process catalog from the draft 3.991, mapped to 3.1
  121. schema/ item types, links, coverage rules; file layout of an item
  122. tools/ trace engine, record writer, validators, tests
  123. .claude/skills/ one skill per activity
  124. .claude/agents/ roles with boundaries; the reviewing agent cannot write
  125. .claude/hooks/ protection and checks on every write
  126. .claude/docs/ working agreement, command reference, review checklists
  127. docs/ user guide
  128. .claude-plugin/ plugin manifest and marketplace; hooks/hooks.json runs the hooks from the plugin
  129. examples/ power-window (software supplier), door-control-unit (system supplier)
  130. ci/ pipeline templates for projects (GitHub Actions, GitLab CI)
  131. ```
  132. Three ideas carry the design:
  133. 1. **Facts come from tools.** Coverage, link status and test results are computed or
  134. taken from tool output, never stated from memory. Evidence records are written by
  135. tooling.
  136. 2. **Approval is bound to content.** A review record names each item with a content
  137. hash and the upstream versions it was compared against. Change the item and its
  138. approval is stale; change an upstream item and the links to it are suspect.
  139. 3. **Scope decides the rules.** A project declares the processes it is responsible
  140. for. Only their rules apply, and what comes from outside is an imported input that
  141. is accepted, not edited.
  142. The rules of work are in [.claude/docs/working-agreement.md](.claude/docs/working-agreement.md).
  143. ## Automotive SPICE
  144. Automotive SPICE is a registered trademark of the Verband der Automobilindustrie e.V.
  145. (VDA). This project is not affiliated with or endorsed by the VDA. It does not
  146. reproduce the Automotive SPICE process assessment model: it refers to processes, base
  147. practices and work products by their identifiers and official names and describes what
  148. they expect in its own words. The model itself is available from the VDA QMC and is
  149. the reference for anything normative.
  150. ## License
  151. MIT, see [LICENSE](LICENSE).

Ratings and comments

Sign in to rate this skill.

Sign in

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