SkillAgentSearch skills...

specifying-plant-models

Specify plant models for closed-loop simulation: system specs, architecture, build plans, validation plans

Install / Use

npx skills add matlab/simulink-agentic-toolkit --skill specifying-plant-models

Installs into whichever agent you are using.

About this skill
📄

SKILL.md

Installable skill definition

Quality Score

87/100

Supported Platforms

Universal

Our assessment of specifying-plant-models

specifying-plant-models scores 87/100 on our quality scale, 2197th of 4,716 Development & Engineering skills we index (top 47%).

Its SKILL.md is 8.5 KB long, well organised into 18 sections with 2 code examples: a thorough specification that gives an agent plenty to work with.

With 1,148 GitHub stars, it is one of the more widely adopted skills in the catalogue.

Substance
29/30
Structure
18/20
Description
12/15
Adoption
13/20
Freshness
15/15

Maintenance, license and trust

  • The repository was last updated about 2 months ago, so specifying-plant-models is actively maintained.
  • Our last check on 2026-10-11 found the source still online.
  • No license is declared. By default that means all rights are reserved: you can read it, but reusing or redistributing it is not clearly permitted. Ask the author before building on it commercially.
  • Its trust signals score 88/100, with 1 caution from licensing, adoption, age or documentation. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.

AI review by kimi-k2.7-code on 2026-10-06. Automated pattern scan on 2026-10-05. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.

specifying-plant-models compared with similar skills

All 4 of these similar skills score higher than specifying-plant-models; compare them before choosing.

SkillScoreStarsUpdatedFormat
specifying-plant-models (this skill)by matlab871.1k2mo agoSKILL.md
taste-skillby Leonxlnx100118.9k11d agoCLAUDE.md
hyperframesby heygen-com10087.1ktodayCLAUDE.md
ai-job-searchby ai-job-search-dev10072.6ktodayCLAUDE.md
claude-howtoby luongnv8910047.5k5d agoCLAUDE.md

Frequently asked questions

How do I install specifying-plant-models?
Run npx skills add matlab/simulink-agentic-toolkit --skill specifying-plant-models. The install tabs above show the steps for each supported agent.
Which AI agents does specifying-plant-models work with?
It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
Is specifying-plant-models safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It declares no license and scores 88/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is specifying-plant-models still maintained?
The repository was last updated about 2 months ago, so specifying-plant-models is actively maintained.

name: specifying-plant-models description: "Specify plant models for closed-loop simulation: system specs, architecture, build plans, validation plans. Use when creating, updating, or reviewing plant model specifications, planning plant model architecture, or planning plant model validation." license: https://www.mathworks.com/content/dam/mathworks/license/pmrl/license.md metadata: author: MathWorks version: "1.1"

Plant Model Specs

Structured specification of plant models for closed-loop simulation. Adapts the specifying-software templates for the physics-modeling domain.

When to Use

  • Creating a plant model to close the loop with an existing controller
  • Updating or extending an existing plant model spec
  • Specifying a plant model before building it
  • Deciding on model architecture (subsystem decomposition, fidelity level)
  • Planning validation of a plant model

When NOT to Use

  • Building the plant model → use building-simulink-models
  • Testing an existing plant model → use testing-simulink-models
  • Specs for controller algorithms or MBD algorithms → use specifying-mbd-algorithms
  • Specs for traditional software (C, C++, Python, MATLAB scripts) → use specifying-software
  • Specifying a full closed-loop system → use specifying-mbd-algorithms for the algorithm side, this skill for the plant side

Output Conventions

Store specs per plant model. Prefix every filename with the plant name so files are self-identifying in editor tabs, search results, and flat listings:

docs/specs/plant-models/<plant-name>/
├── <plant-name>-system.md              # What & why
├── <plant-name>-architecture.md        # Subsystem decomposition
├── <plant-name>-implementation-plan.md # Build sequence
└── <plant-name>-test-plan.md           # Validation plan

Example for a plant called motor:

docs/specs/plant-models/motor/
├── motor-system.md
├── motor-architecture.md
├── motor-implementation-plan.md
└── motor-test-plan.md

Mode Selection

Does this plant have <5 states, single-rate dynamics, no strong nonlinearities, and will be built by one person/agent?

  • Yes → Quick spec: 2 documents (system+architecture combined, implementation+test combined)
  • No → Full spec: 4 separate documents

Document Boundaries

| Spec | Answers | Does NOT Contain | |------|---------|------------------| | System | What are we building and why? | Subsystem decomposition, equations | | Architecture | How is it structured? | Simulink block details, parameter values | | Implementation Plan | How do we build it? | Actual model_edit commands | | Test Plan | How do we validate it? | Test execution results |

In quick mode, combine system+architecture and implementation+test into two documents.

Workflow

Step 1: Analyze Controller Interface

Read the controller model with model_overview and model_read. Classify every signal as:

  • u (commanded inputs from controller), w (exogenous disturbances),
  • y (measured outputs to controller, with sensor effects), z (truth outputs for debugging)

Define the plant boundary and document sample times.

Step 2: Assess Validation Evidence

Before researching the domain, establish what evidence exists: test data, datasheets, standard maneuvers, analytic expectations, reference models.

Fidelity must be justified by available evidence — no point modeling dynamics you can't validate. Intended use matters: MIL rapid iteration → lower fidelity acceptable; HIL/code generation → fixed-step, real-time constraints.

Step 3: Research the Physics Domain

Use web_search and read_web_page for standard modeling approaches, reference parameters, and authoritative sources. Consult references/plant-model-guidance.md for cross-domain patterns if needed.

Step 4: Write System Spec

Use assets/system-spec-template.md. Key plant-model sections: operating scenarios, physical model requirements, controller interface contract (u/w/y/z with sample times, data types, units), initialization & operating points, rate & timing alignment, validation evidence, reference sources.

Review gate before proceeding — verify:

  • Completeness of interface requirements (u, y signals covered)
  • Appropriate fidelity given intended use AND available validation evidence
  • Coverage of controller's operating envelope in operating scenarios
  • Operating points / initialization strategy specified and feasible
  • Rate/sample time alignment with controller defined
  • Clear validation reference for each major requirement

Get user review before proceeding.

Step 5: Write Architecture Spec

Use assets/architecture-spec-template.md. Key plant-model sections: component catalog with physics domain and port interfaces, equations of motion per subsystem, nonlinearities & constraints, numerical considerations (solver, stiffness, algebraic loops), parameter management, uncertainty hooks.

Review gate before finalizing — verify:

  • Correct physics decomposition — subsystem boundaries at natural domain boundaries
  • Complete signal flow from u through dynamics to y
  • Disturbances w entering at the right points
  • Consistent interfaces: units, sign conventions, coordinate frames end-to-end
  • DAE / algebraic loop risks addressed; conservation laws respected
  • Missing dynamics that affect the controller (actuator limits, sensor noise, transport delays)

Get user review before proceeding.

Step 6: Write Implementation Plan + Test Plan

Use assets/implementation-plan-template.md and assets/test-plan-template.md.

Implementation plan essentials:

  • Phase 0 (interface contract & stubs) gates all parallel work — freeze ports/units/sign conventions first
  • Loosely coupled subsystems (sensors, actuators, load, environment) can be built by separate agents concurrently after Phase 0; tightly coupled splits (inverter↔motor, tire↔chassis) need coordination
  • Model References enable the strongest parallel development (separate .slx files)
  • Parameter table: every parameter with name, value, unit, source, block path
  • Sync points use model_read verification and model_query_params spot-checks

Test plan essentials:

  • Three-stage validation: subsystem open-loop → integrated open-loop → closed-loop
  • Input signal definitions with parameters (step, ramp, sine sweep)
  • Gherkin scenarios mapped to model_test format
  • Quantitative acceptance criteria with physical justification

Review gate — Implementation Plan — verify:

  • Realistic bottom-up build order (leaf subsystems first)
  • Phase 0 interface stubs gate parallel work
  • Correct Simulink block types for the physics
  • Solver choice matches stiffness + discrete elements
  • Complete parameter table with sources and units

Review gate — Test Plan — verify:

  • Validation staging: subsystem open-loop → integrated open-loop → closed-loop (MIL)
  • Real-time execution feasibility assessed if plant is HIL-targeted
  • Each maneuver specifies: input, outputs, comparison method, acceptance criteria
  • Parameter sensitivity checks included
  • Numerical robustness test (solver tolerance, step size)
  • Gherkin scenarios executable via model_test

Get user approval before building begins.

Guardrails

Always

  • Classify signals as u/w/y/z at every interface
  • Cite sources for every parameter (value, unit, source, uncertainty, conditions)
  • Assess validation evidence before choosing fidelity level
  • Decompose into subsystems at natural domain boundaries (actuator, dynamics, sensor, environment, load)

Ask First

  • Fidelity level changes after system spec is approved
  • Adding subsystems not in the architecture spec
  • Deviating from the controller's sample time alignment

Never

  • Reproduce textbook derivations in specs — cite authoritative sources instead; use web_search for domain-specific research
  • Model dynamics you cannot validate against available evidence
  • Skip Phase 0 interface stubs when parallel building is planned
  • Use web_search results from unvetted sources — prefer standards, textbooks, MathWorks docs, and peer-reviewed papers

References

  • assets/system-spec-template.md — System spec template (what & why)
  • assets/architecture-spec-template.md — Architecture template (subsystem decomposition)
  • assets/implementation-plan-template.md — Build sequence template
  • assets/test-plan-template.md — Validation plan template
  • references/plant-model-guidance.md — Optional domain reference (decomposition examples, validation maneuvers, solver guide). Human-facing; do not copy verbatim into specs.

Copyright 2026 The MathWorks, Inc.


Related Skills

View on GitHub
GitHub Stars1.1k
CategoryDevelopment
Updated2mo ago
Forks106

Languages

HTML

Trust signals

88/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

1 medium