LibreEmbed Claude Code

Embedded systems, firmware, and IoT development with Claude Code — 15 specialized plugins from bare metal to RTOS

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

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

Communication + I/O

Runtime + system

Hardware-software integration

Quality + compliance

Optional safety hooks

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 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.
• 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, ESP32, Renesas RA), 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.

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)
• calcinate-skills — Stage 1 of the Magnum Opus (burn project bloat)
• claude-md-overhaul-skills — Audit CLAUDE.md and MEMORY.md against caps
• session-handoff-skills — Session handoff and pickup discipline
• naming-skills — Product naming methodology (mine the brand's vocabulary)
• magnum-opus-skills — Seven-stage alchemy applied to project transformation
• mem-search-skills — Search claude-mem cross-session memory: search, filter, fetch
• hypothesis-debugging-skills — Hypothesis-driven debugging: reproduce, isolate, test, fix
• vibe-proof-skills — Security hardening for vibe-coded full-stack apps
• tdd-skills — Test-driven development (Red-Green-Refactor) for JS/TS and Python
• mars-skills — Production-readiness audit: the five mortal sins of vibe-coded MVPs
• git-workflow-skills — Clean git workflow: branch, atomic commits, reviewable PRs
• code-review-skills — Domain-aware code review: classify the code, then focus
• code-comprehension-skills — Understand an unfamiliar codebase fast
• dx-audit-skills — Audit developer experience: docs, onboarding, tooling friction
• setup-env-skills — Set up a project's development environment
• automate-skills — Turn repetitive tasks into reliable automation scripts
• quick-fix-skills — Fast troubleshooting for common issues
• prime-context-skills — Prime project context at the start of a session
• auto-docs-skills — Generate and maintain project documentation
• learning-skills — Learn any technology: roadmaps, explanations, practice, cheatsheets, comparisons
• linux-sysadmin-skills — Linux system administration: security, performance, diagnostics, monitoring, maintenance

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.