Development skills

Use this guide to understand AgentDock and manage its configuration across desktop apps, Linux services, Docker, and direct binary runs. It helps identify the active instance, apply changes, restart the right process, verify behavior, and connect Coding Agents through ACP.

• Finding where an AgentDock setting lives
• Applying a configuration change and checking that it took effect
• Restarting and health-checking the correct AgentDock process

Plan plant models for closed-loop simulation, from system requirements and controller interfaces to subsystem architecture, implementation steps, and validation plans. It helps match model detail to intended use and available evidence, then organizes the specifications for review before building begins.

• Specifying a plant for an existing controller
• Planning subsystem architecture and model fidelity
• Preparing plant implementation and validation plans

Build and edit Simulink models that process audio, vibration, radar, or communications signals in frames. Choose suitable DSP blocks, configure buffering and sample-rate conversion, and check signal dimensions and rates to catch numerical mistakes that may not produce errors.

• Building a frame-based audio or vibration processing model
• Adding filters or buffering to a streaming DSP pipeline
• Changing sample rates with decimation or resampling

Build and edit Simulink, System Composer, Stateflow, and Simscape models by changing blocks, parameters, connections, architecture components, or chart internals. The workflow checks the resulting structure and flags unconnected ports or dangling lines.

• Adding or connecting model blocks
• Editing Stateflow chart contents
• Building System Composer architectures

Integrate custom, legacy, or external C and C++ code into a Simulink model through a C Function block. Configure its inputs, outputs, persistent state, and parameters programmatically with the SymbolSpec API.

• Wrap a C or C++ function for use in Simulink
• Add a C Function block to a model
• Integrate a C++ class into a model or test bench

Improve block selection from custom Simulink libraries by adding intent-focused descriptions, correcting categories, and marking commonly used blocks. The curated information helps the model-building agent find blocks that fit the modeling task.

• Improve descriptions for blocks with little metadata
• Correct a block's automatically assigned category
• Mark frequently used blocks as common

Create synthetic waveforms such as steps, ramps, sine waves, chirps, pulses, and noise for Simulink inports. Populate an External Inputs or Signal Editor Dataset while preserving signal types, dimensions, units, and interpolation metadata, including timing for trigger and function-call inputs.

• Creating waveform data for Simulink inports
• Filling an empty input Dataset with test signals
• Preparing Signal Editor scenarios

Bring logged data into the Simulation Data Inspector (SDI) from MAT, CSV, or Excel files, workspace variables, or a completed Simulink simulation. Choose the appropriate `createRun` source, avoid duplicate runs when simulation logging already populated SDI, and verify the imported signals.

• Viewing a MAT, CSV, or Excel log in SDI
• Loading bench-test data from a file
• Opening signals logged by a completed simulation

Create or upgrade Model Advisor checks for Simulink and System Composer rules. The workflow covers guideline writing, check specifications, implementation, and qualification tests, including converting legacy check styles to the modern DetailStyle format.

• Turn a modeling rule into a formal guideline and check
• Create an auto-fix or batch Model Advisor check
• Upgrade a legacy check to modern DetailStyle

Write or edit Simscape Language source files for physical components, domains, and functions. Turn governing equations into component code, adjust parameters or behavior, and validate syntax. Intended for authoring `.ssc` files rather than wiring existing Simulink blocks.

• Creating a Simscape component from physical equations
• Editing component parameters or equations
• Fixing Simscape Language validation errors

Configure Simulink runs without changing the model, override parameters, supply custom input signals, and run batches or parameter sweeps with sim or parsim. The skill also explains how to retrieve logged signals for analysis.

• Compare model behavior across parameter values
• Run many Simulink simulations in batches
• Provide custom signals to model inputs

Register existing `.slx` custom block libraries for Simulink model building, then configure their block policy and knowledge index. It helps an agent recognize available library blocks and manage an existing library setup; it does not create new libraries.

• Register an existing `.slx` block library
• Add library files to an existing configuration
• Set up a block policy for declared libraries

Customize A2L (ASAP2) calibration files exported from Simulink, including conversion methods, groups, axes, bit operations, and variant coding. Use the documented MATLAB APIs to shape exported calibration data for tools such as INCA or CANape.

• Adding or changing conversion methods in an A2L export
• Creating groups for calibration elements
• Adjusting axes or bit operations

Prepare Simulink models for Embedded Coder, Simulink Coder rapid prototyping, or AUTOSAR code generation. Select targets, map hardware, propagate settings through model hierarchies, configure compliance options, and produce code or build reports for deployment workflows.

• Preparing a model for embedded C or C++ generation
• Configuring a model for ECU deployment
• Setting up rapid-prototyping code for a target device

Create, repair, and validate a Classic AUTOSAR software component in Simulink. Configure runnable behavior, timing events, ports, client-server operations, and inter-runnable data, then update component ARXML and inspect generated artifacts when requested.

• Creating or extending a Classic AUTOSAR component
• Configuring runnables and timing events
• Mapping ports, operations, services, or IRVs

Build and refine system architecture models in System Composer across functional, logical, and physical layers. Define interfaces and stereotypes, create views and sequence diagrams, link layers through allocations, and trace requirements to components.

• Design functional, logical, or physical architecture layers
• Set up interface dictionaries and port interfaces
• Create allocation sets between architecture layers

Prepare a Simulink model for external sharing by creating an anonymized, self-contained copy. The workflow can rename model elements, sanitize MATLAB code, remove metadata, resolve dependencies, and report numeric or binary content that remains for manual review.

• Anonymize a model before sharing it outside your organization
• Prepare a reproduction model for a bug report or support case
• Remove proprietary names, code, and metadata from a model

Plan and run repeated Simulink simulations with varying parameters using `parsim`, `batchsim`, or `DesignStudy`. Choose a suitable local or cluster workflow, collect selected metrics, and support parameter sweeps and Monte Carlo studies while managing results across runs.

• Running parameter sweeps across Simulink simulations
• Planning a Monte Carlo study
• Moving long simulation campaigns to a cluster

Set up and maintain MATLAB projects for Simulink workflows. Organize models, data dictionaries, and requirements, configure paths and labels for automation, and investigate broken references or project health issues so project files are easier to resolve and manage.

• Creating a MATLAB project for Simulink models
• Adding dictionaries or requirements to a project
• Setting project paths to resolve model references

Measure and improve C/C++ code generated from Simulink models. The workflow establishes a baseline, proposes model or configuration changes, and checks their impact on execution time, memory use, code size, or MISRA compliance through repeated measurements.

• Reduce generated code execution time
• Lower RAM, ROM, or stack use
• Shrink generated code size

Create and update safety analysis spreadsheets such as FMEA, FHA, and HARA, or build fault trees. Review entries for missing or inconsistent information, flag issues for attention, and export spreadsheet results to Excel using Safety Analysis Manager.

• Drafting an FMEA or hazard analysis from a model or requirements
• Building a fault tree and assessing event probabilities
• Reviewing an existing safety analysis for gaps and duplicates

Make a Simulink model analyzable by Simulink Design Verifier. The skill diagnoses unsupported blocks or settings, applies a matching fix to a copy, and checks compatibility again. An optional replay can compare behavior on generated tests, but does not prove equivalence.

• Find why a model fails the SLDV compatibility check
• Prepare a model copy for SLDV analysis
• Resolve unsupported blocks or configuration settings

Set up or update `.satk/block-policy.json` to control which Simulink blocks an agent may use, which it must exclude, and which block parameters it must leave unchanged. The skill validates policy settings before saving.

• Setting which blocks an agent may use
• Excluding obsolete or disallowed blocks
• Protecting block parameters from edits

Draft behavioral requirements from a Simulink model and save them as a Requirements Toolbox `.slreqx` artifact or structured YAML. The skill uses EARS patterns, preserves stable IDs, and can link requirements to model elements for traceability.

• Draft requirements from a Simulink model
• Update an existing requirements artifact
• Create model-to-requirement traceability links