LibreEmbed-Claude-Code

English | 简体中文

---

Skills, agents, commands, and workflows for embedded systems development with Claude Code.

Most LLM-assisted coding patterns assume a web stack. Embedded development isn't web. The toolchain is GCC + OpenOCD + a hardware debugger. The runtime is bare metal or a 32 KB RTOS. The bugs live in a register on a chip you can hold in your hand. The feedback loop is "compile, flash, watch the LED, decide."

LibreEmbed is the Claude Code stack for that work. Fifteen plugins covering the layers that actually matter when you're bringing up a board, writing a driver, debugging across SWD, or shipping firmware that has to survive a reflash in the field.

---

The shift this kit responds to

Andrej Karpathy framed the broader change in December 2025:

"I've never felt this much behind as a programmer. The profession is being dramatically refactored."

"New vocabulary: agents, subagents, their prompts, contexts, memory, modes, permissions, tools, plugins, skills, hooks, MCP, LSP, slash commands, workflows, IDE integrations..."

Embedded development has resisted that refactor longer than most domains. The reasons are real — proprietary toolchains, hardware-in-the-loop testing, safety constraints, vendor lock-in — but the result is that embedded teams have lagged in adopting agent-assisted workflows. LibreEmbed exists to close that gap. Each plugin encodes a slice of embedded expertise as agent prompts + commands + skills, so the agent can think alongside you when you're trying to figure out why the chip won't enumerate over USB.

Where LibreEmbed fits in the Claude Code stack

Claude Code component	LibreEmbed provides
Plugins	15 domain plugins (RTOS, ARM Cortex-M, comm buses, IoT, FPGA, safety-critical, more), installed from one marketplace named libre-embed
Agents	Domain-specialist agents for each plugin — e.g., RTOS engineer, ARM Cortex-M expert, IoT protocol designer
Commands	Quick-access slash commands per plugin (/rtos, /comm-bus, /iot, /cortex-m, etc.)
Skills	Reusable pattern libraries — calibration routines, sensor fusion, bootloader patterns, OTA workflows
Hooks	Pre/post tool hooks for safety nets, packaged as the optional libre-embed-hooks plugin: asks before flash, erase, and secret-file operations
Templates	A project CLAUDE.md scaffold (templates/CLAUDE.md)

---

What's included

LibreEmbed-Claude-Code/
├── .claude-plugin/         # marketplace.json for the libre-embed marketplace
├── plugins/                # 15 plugins, one per embedded subdomain, plus libre-embed-hooks
│   ├── arm-cortex-m        # ARM Cortex-M0/M3/M4/M7/M33 programming
│   ├── bare-metal          # Register manipulation, linker scripts, minimal runtime
│   ├── bootloader-design   # Bootloader architecture, secure boot, A/B partitions
│   ├── communication-buses # I2C, SPI, UART, CAN, USB protocols + drivers
│   ├── debug-trace         # JTAG, SWD, ITM, ETM, printf debugging, logic analyzers
│   ├── embedded-linux      # Yocto, Buildroot, device trees, kernel modules
│   ├── embedded-testing    # On-target unit tests, HIL testing, hardware mocks
│   ├── firmware-update     # OTA updates, dual-bank flash, rollback mechanisms
│   ├── fpga-integration    # MCU+FPGA integration, soft cores, HDL basics
│   ├── iot-protocols       # MQTT, CoAP, LwM2M, BLE, LoRaWAN, Zigbee, Thread
│   ├── memory-management   # Static allocation, pools, stack/heap analysis
│   ├── power-management    # Sleep modes, power budgeting, energy harvesting
│   ├── rtos-patterns       # FreeRTOS, Zephyr, task design, IPC, priority inversion
│   ├── safety-critical     # IEC 61508, DO-178C, MISRA C, certification patterns
│   ├── sensor-integration  # Driver bring-up, calibration, filtering, fusion
│   └── libre-embed-hooks   # Optional safety hooks: confirm flash, erase, and secret-file operations
├── learning-paths/         # 3 learning paths: beginner → intermediate → advanced
├── templates/              # Project CLAUDE.md scaffold
└── setup.sh                # Installs the plugins through the Claude Code CLI

---

The 15 plugins

Each plugin ships an agent (specialist persona with deep domain knowledge), a command (quick slash invocation), and a skill (reusable pattern library).

Microcontroller core

Plugin	Agent / Command	What it does
arm-cortex-m	cortex-m-engineer / /cortex-m	CMSIS, HAL vs. LL, startup code, vector table, MPU configuration, MMU on Cortex-A boundaries. ARM Cortex-M0+/M3/M4/M7/M33.
bare-metal	bare-metal-engineer / /bare-metal	Register-level programming, linker scripts, minimal runtime (no libc), C++ on embedded, freestanding builds.
memory-management	memory-engineer / /memory	Static allocation strategies, memory pools, stack analysis via GCC -fstack-usage, heap-less design, fragmentation patterns.
power-management	power-engineer / /power	Sleep modes (run / sleep / stop / standby), peripheral clock gating, wake sources, power budgeting, energy harvesting designs.

Communication + I/O

Plugin	Agent / Command	What it does
communication-buses	bus-driver-engineer / /comm-bus	I2C (master/slave, clock stretching, multi-master), SPI (modes, DMA, CS handling), UART (DMA, ring buffers, flow control), CAN (frame format, filters, error states), USB CDC/HID.
sensor-integration	sensor-engineer / /sensor	Sensor driver bring-up, factory calibration, Allan variance, complementary + Kalman filtering, sensor fusion (IMU + magnetometer + GPS).
iot-protocols	iot-protocol-engineer / /iot	MQTT (QoS levels, retained messages, LWT), CoAP, LwM2M device management, BLE GATT, LoRaWAN class A/B/C, Zigbee, Thread.

Runtime + system

Plugin	Agent / Command	What it does
rtos-patterns	rtos-engineer / /rtos	FreeRTOS + Zephyr task design, IPC primitives (queues, mutexes, semaphores, event groups), priority inversion + inheritance, watchdog patterns, deferred interrupt processing.
embedded-linux	embedded-linux-engineer / /embedded-linux	Yocto + Buildroot, device tree authoring, kernel module patterns, init systems (systemd vs. OpenRC vs. BusyBox init), userspace driver patterns.
bootloader-design	bootloader-engineer / /bootloader	First-stage vs. second-stage bootloaders, secure boot chains, signature verification, A/B partition designs, fail-safe rollback, ROM bootloader interaction.
firmware-update	fota-engineer / /firmware-update	OTA update protocols, dual-bank flash, delta updates (bsdiff/Heatshrink), version negotiation, anti-rollback, signed-by-vendor enforcement.

Hardware-software integration

Plugin	Agent / Command	What it does
fpga-integration	fpga-engineer / /fpga	MCU + FPGA designs, AXI bus integration, soft-core CPUs (RISC-V on FPGA), DMA across the boundary, HDL basics for the embedded developer.
debug-trace	debug-engineer / /debug-embedded	JTAG + SWD setup, OpenOCD + pyOCD, ITM (Instrumentation Trace Macrocell), ETM (Embedded Trace Macrocell), printf-over-SWO, logic analyzer captures, oscilloscope vs. logic analyzer trade-offs.

Quality + compliance

Plugin	Agent / Command	What it does
embedded-testing	embedded-test-engineer / /embedded-test	On-target unit tests (Unity, CMocka, Ceedling), Hardware-in-the-Loop (HIL) test rigs, hardware peripheral mocks, golden-image regression, CI for embedded.
safety-critical	safety-engineer / /safety	IEC 61508 SIL levels, DO-178C aviation, ISO 26262 automotive, MISRA C compliance, formal verification basics, freedom-from-interference.

Optional safety hooks

Plugin	Hooks	What it does
libre-embed-hooks	SessionStart, PreToolUse, PostToolUse	Asks before flash and erase commands (OpenOCD program, st-flash write, west flash, idf.py flash, pyocd flash, nrfjprog --program, and more) and before a file tool touches .env, .pem, .key, credentials, or secrets files. Prints one context line when a session opens in a firmware project, and flags a file left empty by an edit. No agents, no logs. See its README.

---

Quick start

Install from Claude Code

/plugin marketplace add HermeticOrmus/LibreEmbed-Claude-Code
/plugin install rtos-patterns@libre-embed

Install any of the 15 plugins the same way, /plugin install <plugin>@libre-embed with a name from the tables above, then restart Claude Code. From a terminal the same two steps are:

claude plugin marketplace add HermeticOrmus/LibreEmbed-Claude-Code
claude plugin install rtos-patterns@libre-embed

The safety hooks are a separate, optional plugin: /plugin install libre-embed-hooks@libre-embed (or claude plugin install libre-embed-hooks@libre-embed).

Install in Grok Build

Grok Build loads the same plugin folders. Add the marketplace and install a plugin from a terminal:

grok plugin marketplace add HermeticOrmus/LibreEmbed-Claude-Code
grok plugin install rtos-patterns@LibreEmbed-Claude-Code

Or install one plugin straight from its folder, with no marketplace:

grok plugin install HermeticOrmus/LibreEmbed-Claude-Code#plugins/rtos-patterns

From a clone, ./setup.sh --grok installs every plugin through the grok CLI; --only, --list, and --uninstall work the same way. The libre-embed-hooks plugin uses a hook format Grok Build supports, but it has not been verified in a live Grok session yet.

Install everything with setup.sh

# Clone
git clone https://github.com/HermeticOrmus/LibreEmbed-Claude-Code.git ~/projects/LibreEmbed-Claude-Code

# Install all 15 plugins plus libre-embed-hooks into Claude Code
cd ~/projects/LibreEmbed-Claude-Code
./setup.sh

# Or install just the plugins you need
./setup.sh --only rtos-patterns,communication-buses,iot-protocols

# List the plugins, skip the hooks plugin, or remove the pack
./setup.sh --list
./setup.sh --no-safety-hooks
./setup.sh --uninstall

setup.sh needs the claude CLI and jq. It registers the checkout as the libre-embed marketplace and runs claude plugin install for each plugin, so it installs exactly what the /plugin commands install. All fifteen together add about 4.7k tokens of plugin descriptions to every session (claude plugin details <plugin>@libre-embed shows each one), so --only pays off if you work in a few areas.

Upgrading from 0.x: the old setup.sh copied directories into ~/.claude/plugins/ and scripts into ~/.claude/hooks/, locations Claude Code does not load. Install with either method above, then delete any leftover ~/.claude/plugins/libre-embed-* directories and ~/.claude/hooks/libre-embed-*.sh scripts.

First prompt

Then in any Claude Code session at your firmware project root:

/rtos design a task structure for a sensor logger that samples 4 channels at 1 kHz and writes to QSPI flash every 100 ms

If another plugin also defines /rtos, use the namespaced form /rtos-patterns:rtos.

See QUICK_START.md for the full walkthrough on a real board (STM32F4 Discovery + ICM-20948 IMU).

---

Learning paths

The repo is organized by experience level. Pick your entry point:

Beginner — "My first MCU project with Claude Code"

You've programmed C. Maybe you've blinked an LED on Arduino. You want to graduate to a real MCU + GCC toolchain + a hardware debugger, with Claude Code helping you avoid the obvious mistakes.

→ learning-paths/beginner.md

Intermediate — "Bring up a custom board"

You have a schematic + a populated PCB on your desk. The crystal is the right frequency. The power rails measure clean. Now you need to write the first firmware that confirms the board works. Claude Code as your bring-up partner.

→ learning-paths/intermediate.md

Advanced — "Ship firmware that survives the field"

OTA updates that don't brick devices. Watchdog patterns that catch real failures. CI/CD for firmware. Long-term support patterns. The work that makes firmware credible for production.

→ learning-paths/advanced.md

---

Compatibility

• Claude Code: a release with plugin marketplaces (/plugin); this release was verified with Claude Code 2.1.285. setup.sh and the hooks plugin also need jq.
• Grok Build: grok 1.0.44 validates and installs all 16 plugins. The hooks plugin is unverified in a live Grok session.
• Toolchains: GCC ARM (any recent version), Clang/LLVM with embedded targets, Zephyr SDK, ESP-IDF, STM32CubeIDE, Microchip XC32, Renesas e² studio
• MCU families covered: ARM Cortex-M0/M0+/M3/M4/M7/M33 (STM32, NXP LPC + Kinetis + i.MX RT, Nordic nRF, Microchip SAM, RP2040, Renesas RA), Espressif ESP32 with Xtensa cores (ESP32, ESP32-S2, ESP32-S3) or RISC-V cores (ESP32-C and ESP32-H series), MSP430 (light), AVR (light)
• RTOS coverage: FreeRTOS (deep), Zephyr (deep), ThreadX (moderate), RT-Thread (light)
• Build systems: Make, CMake, PlatformIO, Zephyr west, ESP-IDF idf.py
• Debuggers: SEGGER J-Link (preferred), ST-Link, CMSIS-DAP, Black Magic Probe, JLink-OB
• OS: Linux / macOS for development host (Windows tolerated, WSL2 recommended)

LibreEmbed makes no calls home and does not require any vendor account beyond what your toolchain itself needs.

---

Feedback

Starred this? Tell us what worked and what is missing: open a feedback issue. Every piece of feedback gets an answer, and changes that come from it are credited in the release notes.

Cracks we found and sealed: LEDGER.md.

---

Contribute

• Take the next piece of work from the Menu, or start with a good first issue.
• Claude picked the wrong agent or skill? File a routing miss.
• Have a plugin in mind? Open a plugin proposal. Anything else goes in the feedback form.
• Show your boards and firmware in Discussions.

How to claim an item and test a change locally: Ways to contribute.

---

Contributing

Embedded is wide. Fifteen plugins is a start; depth varies per plugin (see CHANGELOG.md for the per-plugin maturity matrix). PRs are especially welcome for:

• RTOS other than FreeRTOS + Zephyr (ThreadX, RT-Thread, NuttX, ChibiOS deeper coverage)
• Vendor-specific HALs (we lean on CMSIS today; vendor HAL conventions need their own plugins or sub-plugins)
• Regional certifications (CCC China, KC Korea, etc.) — the safety-critical plugin is Western-cert-centric today
• Toolchain support (Microchip XC32, Renesas e², IAR, Keil — currently GCC-centric)
• Worked examples with real hardware — the more real-board demos, the more credible the bundle

See CONTRIBUTING.md for the contribution model.

---

Part of the Libre Open-Source Stack for Claude Code

This repository is part of a growing family of open-source toolkits for Claude Code.

Libre suite — comprehensive plugin bundles

• LibreUIUX-Claude-Code — UI/UX development (152 agents, 70 plugins, 76 commands, 74 skills)
• LibreArch-Claude-Code — Software architecture and system design
• LibreCopy-Claude-Code — Technical writing and documentation engineering
• LibreDevOps-Claude-Code — DevOps engineering and infrastructure automation
• LibreFinTech-Claude-Code — Financial technology development
• LibreGEO-Claude-Code — AI-search optimization (ChatGPT, Perplexity, Gemini, Google AI Overviews)
• LibreGameDev-Claude-Code — Game development across Godot, Unity, Unreal
• LibreMLOps-Claude-Code — ML engineering and AI operations
• LibreMobileDev-Claude-Code — Mobile app development (Flutter, React Native, native iOS, native Android)
• LibreSecOps-Claude-Code — Security operations
• LibreSessionFlow-Claude-Code — Session lifecycle: handoff, pickup, absorb, explore, close

Skills mini-repos — single CLAUDE.md drop-ins

• vibe-engineer-skills — Direct AI codegen well: hypothesis before help, scoped prompts, validate before accepting
• markdown-discipline-skills — Strip AI-slop from markdown (no em dashes, no marketing fluff)
• shell-safety-skills — set -euo pipefail discipline plus 15 failure-mode examples
• commit-standard-skills — Ormus Commit Standard v1.0 plus commit-msg hook and commitlint
• unwoke-skills — Strip AI theater (ten sins to eliminate, symmetric engagement)
• python-conventions-skills — Modern Python 3.11+ (types, pathlib, async, ruff, mypy, uv)
• typescript-conventions-skills — TypeScript strict mode, discriminated unions, Result types
• hermetic-laws-skills — Seven Hermetic Principles applied to engineering
• riper-workflow-skills — Research / Innovate / Plan / Execute / Review systematic dev
• six-day-cycle-skills — Sustainable shipping cadence with mandatory rest
• token-optimization-skills — Claude Code token and context optimization
• osint-skills — OSINT research methodology (multi-wave investigative spiral)

Template source

• andrej-karpathy-skills — the canonical single-file CLAUDE.md pattern (fork of jiayuan_jy's original)

Star the family, not just one — that's how the suite stays coherent.