Skip to content

matlab/agent-skills-playground / demos/embedded-ai-deployment/skills/embedded-ai-deployment

embedded-ai-deployment

Verified

Deploy AI models to embedded hardware using MathWorks tools (MATLAB, Simulink, Embedded Coder). Covers two workflow patterns: (1) MathWorks-native or 3P-imported models rebuilt as dlnetwork for lean hardware (Cortex-M, DSP), (2) direct C/C++ code generation from PyTorch and LiteRT models for high-performance hardware (Cortex-A, x86, GPU). Trigger when: user wants to deploy AI to embedded targets; generate C/CUDA from neural networks; compress AI models for MCU/DSP; integrate AI in Simulink for system-level simulation; import PyTorch/ONNX/TensorFlow models for embedded deployment; optimize AI for resource-constrained hardware; or use loadPyTorchExportedProgram, importNetworkFromPyTorch, dlquantizer, exportNetworkToSimulink, or Embedded Coder with AI models.

references/pattern1/codegen-embedded.md

View on GitHub
# Code Generation for Embedded Targets

Patterns for generating embedded C/C++ code from trained AI models using MATLAB Coder,
Simulink Coder, and Embedded Coder.

## Toolbox Requirements

| Toolbox          | Purpose                                     | Required? |
|------------------|---------------------------------------------|-----------|
| MATLAB Coder     | Generate C/C++ from MATLAB code             | Yes       |
| Simulink Coder   | Generate code from Simulink models          | Yes (if using Simulink) |
| Embedded Coder   | Optimized embedded code + IDE integration   | Strongly recommended |

### Embedded Coder Warning

If Embedded Coder is NOT available, always inform the user:

> "**Warning:** Embedded Coder is not installed. Code generated by MATLAB Coder
> or Simulink Coder alone may not be optimized for your embedded target.
> Without Embedded Coder, you may experience:
> - Larger code footprint (ROM/RAM)
> - Suboptimal execution speed
> - Limited target-specific optimizations
> - No direct IDE integration
> - Code may not meet production coding standards (MISRA, CERT)
>
> For production deployment on resource-constrained hardware, installing
> Embedded Coder is strongly recommended."

---

## Network Compatibility for Code Generation

Before creating a predict function, ensure the network is codegen-compatible:

| Network Type | Direct MATLAB Coder (`coder.loadDeepLearningNetwork`) | Simulink Path (`exportNetworkToSimulink` → `slbuild`) |
|-------------|----------------|-----------------|
| Standard `dlnetwork` | Supported (float32 C) | Supported (float32 C) |
| Projected network (`lstmProjectedLayer`, `gruProjectedLayer`, or `ProjectedLayer` over conv/FC/stateful-I/O LSTM/GRU) | **Supported** — generic C/C++ only, no MKL-DNN / ARM Compute acceleration. A `ProjectedLayer` over a stateful LSTM/GRU is not supported; unpack with `unpackProjectedLayers(net)` first | **Supported directly in R2026a** — `exportNetworkToSimulink` accepts projected networks; no unpack required |
| Quantized network from `quantize()` | **NOT supported** — use the pre-quantized network | **SUPPORTED** — generates fixed-point C (int8/int16/int32). This is the recommended path for quantized deployment. See [Export Quantized Network to Simulink](https://www.mathworks.com/help/deeplearning/ug/export-quantized-network-to-simulink.html) |

### Validate Codegen Compatibility

Before generating code, run the analysis function to check for unsupported layers:

```matlab
analyzeNetworkForCodegen(netNative, TargetLibrary='none');
```

This reports any layers or operations that will fail during code generation.

---

## Code Generation from MATLAB (MATLAB Coder)

### Step 1: Create a Predict Function

Wrap the trained model in a standalone prediction function suitable for code generation.

**For dlnetwork (tabular/image data):**

```matlab
function y = predictDLNet(net, x)
    %predictDLNet Run inference with a dlnetwork
    %
    % This function is designed for code generation.

    arguments
        net     dlnetwork
        x       (1,:) single
    end

    dlX = dlarray(x, "CB");
    dlY = predict(net, dlX);
    y = extractdata(dlY);
end
```

**For dlnetwork (LSTM/GRU sequence models -- one time step at a time):**

```matlab
function y = predictSeqDLNet(net, x)
    %predictSeqDLNet Run stateful sequence inference with a dlnetwork
    %
    % Input x is one time step: (1, numFeatures) single.
    % The network must be stateful (maintains hidden state between calls).
    % Without dlarray wrapping, codegen fails with:
    %   "Input data argument to predict must be dlarray type."

    arguments
        net     dlnetwork
        x       (1,:) single
    end

    dlX = dlarray(x, "TC");  % Time x Channels for sequence models
    dlY = predict(net, dlX);
    y = extractdata(dlY);
end
```

**For fitcnet:**

```matlab
function [label, score] = predictClassifier(mdl, x)
    %predictClassifier Run classification inference
    %
    % This function is designed for code generation.

    arguments
        mdl     ClassificationNeuralNetwork
        x       (1,:) single
    end

    [label, score] = predict(mdl, x);
end
```

**For fitrnet:**

```matlab
function y = predictRegressor(mdl, x)
    %predictRegressor Run regression inference
    %
    % This function is designed for code generation.

    arguments
        mdl     RegressionNeuralNetwork
        x       (1,:) single
    end

    y = predict(mdl, x);
end
```

### Step 2: Configure Code Generation

**Standard MATLAB Coder configuration:**

```matlab
% Create configuration for static library
cfg = coder.config("lib");

% Set target language
cfg.TargetLang = "C";

% Configure for embedded target
cfg.HardwareImplementation.ProdHWDeviceType = "ARM Compatible->ARM Cortex-M";

% Enable single-precision (important for lean hardware)
cfg.PurelyIntegerCode = false;  % Set true if target has no FPU

% Set code generation report
cfg.GenerateReport = true;

% Optimize for speed or size
cfg.BuildConfiguration = "Faster Runs";  % or "Smaller Size"
```

**Embedded Coder configuration with native dlnetwork support:**

```matlab
cfg = coder.config('lib', 'ecoder', true);
cfg.TargetLang = 'C';
cfg.GenerateReport = true;
cfg.GenCodeOnly = true;

% Use 'none' for native dlnetwork (no third-party deep learning library)
cfg.DeepLearningConfig = coder.DeepLearningConfig('none');

% Separate weight files for large networks
cfg.LargeConstantThreshold = 0;    % Weights in .bin files

cfg.SupportNonFinite = false;

% ARM Cortex-M (single-core MCU)
cfg.HardwareImplementation.ProdHWDeviceType = 'ARM Compatible->ARM Cortex-M';
cfg.EnableOpenMP = false;
```

**ARM Cortex-A configuration (multi-core SBC):**

```matlab
% cfg.Hardware = coder.hardware('Raspberry Pi');
% cfg.InstructionSetExtensions = 'Neon v7';
% cfg.EnableOpenMP = true;
cfg.HardwareImplementation.ProdHWDeviceType = 'ARM Compatible->ARM Cortex-A';
```

### Step 3: Define Input Types and Generate

```matlab
% Define input types matching your model
numFeatures = 10;  % Match your feature count
inputType = coder.typeof(single(0), [1 numFeatures]);

% For dlnetwork, also specify the network
netType = coder.loadDeepLearningNetwork("trainedNet.mat");

% Generate code
codegen -config cfg predictDLNet -args {netType, inputType} -report
```

### Step 3b: Generate MEX First for Desktop Validation

Before generating a static library for the target, generate a MEX function to
validate the pipeline on the desktop:

```matlab
% Generate MEX for desktop testing
cfgMex = coder.config("mex");
codegen -config cfgMex predictDLNet -args {netType, inputType} -report

% Compare MEX output to MATLAB output
yMATLAB = predictDLNet(net, xSample);
yMEX    = predictDLNet_mex(net, xSample);
maxDiff = max(abs(yMATLAB - yMEX));
fprintf("Max MEX vs. MATLAB difference: %e\n", maxDiff);
```

MEX validation catches code generation issues (unsupported operations,
dimension mismatches) without requiring the target cross-compiler toolchain.

### Step 4: Numerical Equivalency -- Generated Code vs. MATLAB/Simulink

After MEX generation, validate that the generated code produces numerically
equivalent results to both the MATLAB compressed model and the Simulink model.

```matlab
%% Numerical Equivalency: Full Pipeline Validation
% Compare: MATLAB compressed model vs MEX vs Simulink
numTests = 100;  % As agreed with user
errMex = zeros(numTests, 1);
errSimulink = zeros(numTests, 1);

for i = 1:numTests
    xTest = single(testInputs{i});

    % MATLAB reference
    yMatlab = predictDLNet(net, xTest);

    % MEX output
    yMex = predictDLNet_mex(net, xTest);

    % Simulink output (if available from Phase 6)
    ySimulink = simulinkOutputs(i, :);

    errMex(i) = max(abs(yMatlab(:) - yMex(:)));
    errSimulink(i) = max(abs(yMatlab(:) - ySimulink(:)));
end

fprintf('\nFull Pipeline Numerical Equivalency Report\n');
fprintf('============================================\n');
fprintf('Tests run:                %d\n', numTests);
fprintf('MATLAB vs MEX -- MAE:    %.4e, Max: %.4e\n', mean(errMex), max(errMex));
fprintf('MATLAB vs Simulink MAE:  %.4e, Max: %.4e\n', mean(errSimulink), max(errSimulink));
fprintf('Pipeline status:         %s\n', ...
    iif(max(errMex) < 1e-5 && max(errSimulink) < 1e-4, 'PASS', 'INVESTIGATE'));
```

This validates the complete chain: 3P model → MATLAB import/rebuild → compression →
Simulink → generated code. All stages must agree within expected tolerances.

### Step 5: Review Generated Code and Open Report

**ALWAYS** open the code generation report when code generation is complete:

```matlab
% Open the code generation report
% For MATLAB Coder (direct codegen):
reportPath = fullfile('codegen', 'lib', 'predictDLNet', 'html', 'report.mldatx');

% For Simulink/Embedded Coder (slbuild):
% The report is in <modelName>_ert_rtw/html/ — use rtw.report.open:
codeDir = fullfile(pwd, [modelName '_ert_rtw']);
rtw.report.open(modelName, codeDir);

% Fallback: open the HTML report directly
if ~isfile(reportPath)
    htmlReport = fullfile(codeDir, 'html', 'index.html');
    if isfile(htmlReport)
        web(htmlReport);
    else
        % Search for any report file
        reportFiles = dir(fullfile(pwd, '**', 'report.mldatx'));
        if ~isempty(reportFiles)
            open(fullfile(reportFiles(1).folder, reportFiles(1).name));
        end
    end
end

% Check generated files
dir(fullfile(codeDir, '*.c'));
dir(fullfile(codeDir, '*.h'));
```

**NOTE:** For Simulink builds, the report is NOT a `.mldatx` file. Use
`rtw.report.open(modelName, codeDir)` which is printed in the `slbuild` console output.

Announce: "The code generation report is now open. Please review the generated code,
any warnings, ROM/RAM estimates, and code metrics. Let me know if you have questions
or want to adjust any settings."

### Target Support Packages

Embedded Coder support packages for specific hardware targets (e.g., Qualcomm
Hexagon, Infineon AURIX, STMicroelectronics STM32, NXP S32K) must be installed
separately. Check availability via `matlabshared.supportpkg.getInstalled`. If
the required package is missing, direct the user to the Add-On Explorer.

---

## Hardware-Specific Configurations

### ARM Cortex-M (Most Common for Pattern 1)

```matlab
cfg.HardwareImplementation.ProdHWDeviceType = "ARM Compatible->ARM Cortex-M";
% NOTE: ProdBitPerChar/Short/Int/Long/Float/Double and ProdEndianess are
% auto-configured when ProdHWDeviceType is set to a known device.
% These are read-only in R2026a. Only set ProdHWDeviceType.
```

### ARM Cortex-A/R

```matlab
cfg.HardwareImplementation.ProdHWDeviceType = "ARM Compatible->ARM Cortex-A";
```

### Texas Instruments C2000 (DSP)

```matlab
cfg.HardwareImplementation.ProdHWDeviceType = "Texas Instruments->C2000";
```

---

## CMSIS/CMSIS-NN Optimization for ARM Cortex-M

When the deployment target is an ARM Cortex-M processor (M0, M0+, M3, M4, M7, M33),
enable CMSIS optimization for significant performance gains. Requires the **Embedded
Coder Support Package for ARM Cortex-M Processors** (CMSIS library v5.9).

### Supported Layers and Acceleration (R2026a)

Sources:
- [Supported Deep Learning Toolbox Blocks with CMSIS for ARM Cortex-M](https://www.mathworks.com/help/ecoder/armcortexm/ug/supported-deep-learning-blocks-with-cmsis-for-armcortexm.html) — Simulink block replacement (INT8 CMSIS-NN)
- [Code Generation for Matrix Multiplication in DL Layers with CMSIS](https://www.mathworks.com/help/ecoder/armcortexm/ug/code-generation-for-matrix-multiplication-in-dl-layers-with-cmsis-for-armcortexm.html) — float32 mat-mult replacement (CMSIS-DSP)

| Layer | CMSIS-NN (INT8 Simulink block) | CMSIS-DSP (float32 mat-mult) |
|-------|-------------------------------|------------------------------|
| `convolution2dLayer` | `arm_convolve_wrapper_s8` | — |
| `fullyConnectedLayer` | `arm_fully_connected_s8` | `mw_arm_mat_mult_f32` |
| `convolution1dLayer` | — | — |
| `lstmLayer` | — | `mw_arm_mat_mult_f32` |
| `gruLayer` | — | `mw_arm_mat_mult_f32` |
| `bilstmLayer` | — | `mw_arm_mat_mult_f32` |

**Key takeaways:**

- INT8 CMSIS-NN replacement is limited to **Conv2D and FC**. There is no INT8 kernel
  for LSTM/GRU/BiLSTM/Conv1D in R2026a. A quantized recurrent layer generates as
  plain fixed-point C, not an accelerated CMSIS kernel.
- Float32 CMSIS-DSP replacement (`mw_arm_mat_mult_f32`) covers FC, LSTM, GRU,
  BiLSTM. For recurrent-heavy networks where latency matters, the float32 path
  with CMSIS-DSP often outperforms the quantized path.

### Scenario A: Simulink Path with CMSIS CRL (INT8 or float32)

This is the simplest approach — add one configuration line before `slbuild`:

```matlab
% After exportNetworkToSimulink, before building:
set_param(modelName, 'SystemTargetFile', 'ert.tlc');
set_param(modelName, 'ProdHWDeviceType', 'ARM Compatible->ARM Cortex-M');
set_param(modelName, 'CodeReplacementLibrary', 'ARM Cortex-M');
slbuild(modelName);
```

- **With quantized model:** CMSIS-NN INT8 kernels replace **Conv2D and FC blocks only**
  (~2.8–3x speedup on those layers). Quantized LSTM/GRU/BiLSTM layers in the model
  generate as plain fixed-point C — no CMSIS replacement.
- **With float32 model:** CMSIS-DSP `mw_arm_mat_mult_f32` replaces matrix multiply in
  FC, LSTM, GRU, and BiLSTM layers.

### Scenario B: MATLAB Coder Path with CMSIS-NN (INT8, no Simulink)

Use this when Simulink is not available but you still want INT8 CMSIS-NN acceleration.

**Critical:** Do NOT call `quantize()`. The code generator handles quantization
internally using calibration data. This is a different mechanism from the Simulink path.

```matlab
%% Step 1: Calibrate (but do NOT quantize)
quantObj = dlquantizer(net, ExecutionEnvironment="MATLAB");
calibrate(quantObj, calibDs);

% Save the calibration result (NOT a quantized network)
save('calibration_data.mat', 'quantObj');

%% Step 2: Create predict entry-point function
% function out = predict_cmsis(in)
%     persistent net
%     if isempty(net)
%         net = coder.loadDeepLearningNetwork('trained_net.mat');
%     end
%     out = predict(net, in);
% end

%% Step 3: Configure code generation with CMSIS-NN
cfg = coder.config('lib', 'ecoder', true);
cfg.TargetLang = 'C';
cfg.GenerateReport = true;

% CMSIS-NN deep learning configuration
dlcfg = coder.DeepLearningConfig('cmsis-nn');
dlcfg.CalibrationResultFile = 'calibration_data.mat';
cfg.DeepLearningConfig = dlcfg;

% Target hardware
cfg.HardwareImplementation.ProdHWDeviceType = 'ARM Compatible->ARM Cortex-M';

%% Step 4: Generate code
inputType = coder.typeof(single(0), [1 numFeatures]);
codegen -config cfg predict_cmsis -args {inputType} -report
```

**Key differences from Simulink path:**

| | Simulink path | MATLAB Coder CMSIS-NN path |
|---|---|---|
| Calls `quantize()`? | Yes | **No** |
| Requires Simulink? | Yes | **No** |
| Input to code gen | Quantized dlnetwork in Simulink model | Calibration MAT + original network |
| Config object | `set_param(..., 'CodeReplacementLibrary', ...)` | `coder.DeepLearningConfig('cmsis-nn')` |
| Performance | ~2.8–3x | ~1.3x |

### Scenario C: Simulink Path with CMSIS-DSP CRL (float32, LSTM/GRU focus)

For sequence models (LSTM/GRU) where INT8 quantization is not suitable (see
dlquantizer layer support table in compression.md), use the CMSIS-DSP code
replacement for float32 matrix operations:

```matlab
% Export float32 network (unquantized)
exportNetworkToSimulink(net, ModelName="model_lstm", ...
    Stateful=true, InputDataType="single", SampleTime="1");

% Enable CMSIS-DSP CRL — optimizes FC/LSTM/GRU matrix multiplications
set_param('model_lstm', 'SystemTargetFile', 'ert.tlc');
set_param('model_lstm', 'ProdHWDeviceType', 'ARM Compatible->ARM Cortex-M');
set_param('model_lstm', 'CodeReplacementLibrary', 'ARM Cortex-M');
slbuild('model_lstm');
```

### When to Use Each Scenario

Use [`compression-decision.md`](compression-decision.md) to pick the path. Quick
reference:

| Model Type | Goal | Has Simulink? | Recommended |
|-----------|------|---------------|-------------|
| CNN or FC-only model | Flash or latency | Yes | **Scenario A** with quantized model (INT8 CMSIS-NN, ~2.8–3x) |
| CNN or FC-only model | Flash or latency | No | **Scenario B** (MATLAB Coder CMSIS-NN, ~1.3x) |
| LSTM/GRU/BiLSTM model | **Latency** | Yes | **Scenario C** — keep float32, get CMSIS-DSP `mw_arm_mat_mult_f32` |
| LSTM/GRU/BiLSTM model | **Flash** (retraining OK) | Yes | Project + quantize → Scenario A pattern. FC layers get CMSIS-NN INT8; recurrent layers generate as plain fixed-point C (no CMSIS speedup). |
| LSTM/GRU/BiLSTM model | **Flash** (no retraining) | Yes | Quantize → Scenario A pattern. Same caveat: only FC accelerated by CMSIS-NN. |
| LSTM/GRU model | Any goal | No | Standard MATLAB Coder path. CMSIS-DSP `mw_arm_mat_mult_f32` requires the Simulink + ARM Cortex-M CRL path; without Simulink there is no CMSIS replacement for LSTM. |

### PIL Verification with CMSIS

After generating CMSIS-optimized code, validate on actual hardware via PIL:

```matlab
% For Simulink path: set simulation mode to PIL
set_param(modelName, 'SimulationMode', 'processor-in-the-loop');
simOut = sim(modelName);

% For MATLAB Coder path: generate PIL MEX
cfg.VerificationMode = 'PIL';
cfg.Hardware = coder.hardware('STM32F7xx Based');  % or your board
codegen -config cfg predict_cmsis -args {inputType}

% Compare PIL output to MATLAB output
yPIL = predict_cmsis_pil(xTest);
yMATLAB = predict(net, dlarray(single(xTest), "CB"));
maxErr = max(abs(yPIL(:) - extractdata(yMATLAB(:))));
fprintf('PIL vs MATLAB max error: %.4e\n', maxErr);
```

---

## Code Generation from Simulink

### Configure the Model

```matlab
% Open model
open_system("myModel");

% Set solver to fixed-step (required for code generation)
set_param("myModel", "SolverType", "Fixed-step");
set_param("myModel", "FixedStep", "0.001");

% Set system target file
% With Embedded Coder:
set_param("myModel", "SystemTargetFile", "ert.tlc");
% Without Embedded Coder (Simulink Coder only):
set_param("myModel", "SystemTargetFile", "grt.tlc");

% Configure hardware
cs = getActiveConfigSet("myModel");
switchTarget(cs, "ert.tlc", []);
set_param("myModel", "ProdHWDeviceType", "ARM Compatible->ARM Cortex-M");

% Enable code generation report
set_param("myModel", "GenerateReport", "on");
```

### Build the Model

```matlab
% Build and generate code
slbuild("myModel");

% Or use the Embedded Coder app interactively
% embeddedCoderApp("myModel");
```

### Generated Code Structure

Generated code is placed in:
- `<modelName>_ert_rtw/` (Embedded Coder)
- `<modelName>_grt_rtw/` (Simulink Coder)

Key files:
- `<modelName>.c` -- Main model code
- `<modelName>.h` -- Model header
- `<modelName>_data.c` -- Model parameters and weights
- `<modelName>_types.h` -- Type definitions
- `rtwtypes.h` -- Common data types

---

## Code Size Estimation

After code generation, estimate ROM and RAM usage:

```matlab
% Check generated code size
codeDir = "codegen/lib/predictDLNet/";
files = dir(fullfile(codeDir, "*.c"));
totalCodeSize = sum([files.bytes]);

dataFiles = dir(fullfile(codeDir, "*_data.c"));
totalDataSize = sum([dataFiles.bytes]);

fprintf("Generated code size: %.1f KB\n", totalCodeSize / 1024);
fprintf("Data (weights) size: %.1f KB\n", totalDataSize / 1024);
fprintf("Total: %.1f KB\n", (totalCodeSize + totalDataSize) / 1024);
```

For accurate ROM/RAM estimates, compile with the target toolchain and examine
the linker map file.

### WARNING: Generated Data File Size vs. MATLAB Model Size

The `*_data.c` file size does **NOT** equal the MATLAB model's parameter byte count.
The generated C data file is typically **much larger** than expected because:

1. **C source text overhead:** Each weight value is stored as a text literal (e.g.,
   `0.0234375F` takes 10+ bytes in source vs. 4 bytes as float32 binary)
2. **Scaling/offset tables:** Quantized layers include per-layer scale factors,
   zero-points, and accumulator type definitions
3. **LSTM state buffers:** Hidden state and cell state arrays are pre-allocated
4. **Layer types without CMSIS-NN INT8 kernels:** Quantized LSTM/GRU/BiLSTM layers
   generate as plain fixed-point C (CMSIS-NN replacement applies only to Conv2D and
   FC). The fixed-point arithmetic plus state buffers can outweigh the per-weight
   savings. See the CMSIS support table earlier in this file.

**Example:** A model with 55K parameters (~215 KB float32) may produce a `_data.c`
file of 600-700 KB in source text. The **compiled binary** (`.o` / `.elf`) will be
much smaller — use the linker map file for accurate flash usage.

**To estimate actual flash usage:**
```bash
arm-none-eabi-size model.elf
# Or examine the .map file for .rodata and .text section sizes
```

---

## Post-Generation Verification

### Software-in-the-Loop (SIL) Testing

```matlab
% Run SIL test to compare MATLAB and generated code behavior
set_param("myModel", "CodeExecutionProfiling", "on");
set_param("myModel", "CodeProfilingInstrumentation", "on");

% Run SIL simulation
simOut = sim("myModel", "SimulationMode", "software-in-the-loop");
```

### Processor-in-the-Loop (PIL) Testing

```matlab
% Requires target hardware connection
% Run PIL test to verify on actual target processor
simOut = sim("myModel", "SimulationMode", "processor-in-the-loop");
```

---

## Deployment Checklist

Before delivering generated code:

- [ ] Code compiles without errors for target architecture
- [ ] ROM usage within target flash capacity
- [ ] RAM usage within target SRAM capacity
- [ ] Inference time meets latency requirements
- [ ] Numerical results match MATLAB simulation within acceptable tolerance
- [ ] **Full pipeline numerical equivalency validated** (3P → MATLAB → Simulink → C)
- [ ] SIL test passed (simulation vs. generated code agreement)
- [ ] PIL test passed (if target hardware available)
- [ ] No dynamic memory allocation in generated code (for safety-critical)
- [ ] **Code generation report opened** and reviewed for warnings
- [ ] Accuracy loss from compression explicitly documented
writing-skillsobra/superpowersUse when creating new skills, editing existing skills, or verifying skills work before deploymentStars: 322kUpdated Claude CodeCodexVerifiedInstall
xlsxanthropics/skillsUse this skill any time a spreadsheet file is the primary input or output. This means any task where the user wants to: open, read, edit, or fix an existing .xlsx, .xlsm, .xltx, .csv, or .tsv file (e.g., adding columns, computing formulas, formatting, charting, cleaning messy data); create a new spreadsheet from scratch or from other data sources; or convert between tabular file formats. Trigger especially when the user references a spreadsheet file by name or path — even casually (like "the xlsx in my downloads") — and wants something done to it or produced from it. Also trigger for cleaning or restructuring messy tabular data files (malformed rows, misplaced headers, junk data) into proper spreadsheets. The deliverable must be a spreadsheet file. Do NOT trigger when the primary deliverable is a Word document, HTML report, standalone Python script, database pipeline, or Google Sheets API integration, even if tabular data is involved.Stars: 198kUpdated Claude CodeCodexVerifiedInstall
shipping-and-launchaddyosmani/agent-skillsPrepares production launches. Use when preparing to deploy to production, or when asking what needs to be in place before shipping. Use when you need a pre-launch checklist, when setting up monitoring, when planning a staged rollout, or when you need a rollback strategy.Stars: 119kUpdated Claude CodeCodexVerifiedInstall
childhoodthedotmack/claude-memBabysit a shipped release after merge, publication, or deployment. Verify published packages, production behavior, installed plugins, and late CI or user reports until the observation window is clean; use babysit for PR readiness before release.Stars: 118kUpdated Claude CodeCodexVerifiedInstall