embedded-systems

Q: How do I install embedded-systems?

Run npx skills add https://github.com/404kidwiz/claude-supercode-skills --skill embedded-systems in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/embedded-systems/ (personal) or .claude/skills/embedded-systems/ (project).

by 404kidwizBackend & APIs

Expert in RTOS, bare-metal programming, and embedded Linux. Specializes in Rust for Embedded and high-reliability firmware.

Installs: 167
Last 24h: —
Trending rank: —
Security: Not audited

Install

Works with every agent the skills CLI supports.

npx skills add https://github.com/404kidwiz/claude-supercode-skills --skill embedded-systems

01
Install
Run the command in your project. The CLI asks which agents to install for.
02
Describe the task
Ask your agent for something this skill covers. It loads embedded-systems automatically when relevant.
03
Review the result
The agent follows the SKILL.md steps, scripts and references bundled with the skill.

SKILL.md

The instructions your agent reads when the skill is triggered.

Embedded Systems Engineer

Purpose

Provides embedded software development expertise specializing in RTOS, bare-metal firmware, and Embedded Linux. Focuses on safety-critical code, power optimization, and hardware abstraction for microcontrollers (STM32, ESP32) and embedded Linux systems.

When to Use

Writing firmware for microcontrollers (STM32, NXP, ESP32)
Configuring Real-Time Operating Systems (Zephyr, FreeRTOS)
Developing drivers for sensors/peripherals (I2C, SPI, UART)
Building Embedded Linux systems (Yocto, Buildroot)
Implementing OTA (Over-The-Air) update mechanisms
Analyzing crash dumps or debugging hardware faults (JTAG/SWD)

2. Decision Framework

OS Selection

What is the hardware capability?
│
├─ **Microcontroller (MCU) - < 1MB RAM**
│  ├─ Hard Real-Time? → **Zephyr / FreeRTOS** (Preemptive scheduler)
│  ├─ Safety Critical? → **SafeRTOS / Rust (Bare Metal)**
│  └─ Simple Loop? → **Bare Metal (Superloop)**
│
└─ **Microprocessor (MPU) - > 64MB RAM**
   ├─ Complex UI / Networking? → **Embedded Linux (Yocto/Buildroot)**
   └─ Hard Real-Time? → **RT-Linux (PREEMPT_RT)** or **Dual Core (Linux + MCU)**

Language Choice (2026 Standards)

Language	Use Case	Recommendation
C (C11/C17)	Legacy / HALs	Still dominant. Use strict static analysis (MISRA).
C++ (C++20)	Complex Logic	Use `noexcept`, `no-rtti` for embedded. Zero-cost abstractions.
Rust	New Projects	Highly Recommended. Memory safety without GC. `embedded-hal`.
MicroPython	Prototyping	Good for rapid testing, bad for production real-time.

Update Strategy (OTA)

Dual Bank (A/B): Safe but requires 2x Flash.
Compressed Image: Saves Flash, requires RAM for decompression.
Delta Updates: Minimal bandwidth, complex patching logic.

Red Flags → Escalate to security-engineer:

JTAG port left open in production units
Secure Boot keys stored in plain text code
Firmware updates not signed (integrity check only, no authenticity)
Using strcpy or unbounded buffers in C code

Workflow 2: Zephyr RTOS Application

Goal: Read sensor via I2C and print to console.

Steps:

Device Tree (app.overlay)

&i2c1 {
    status = "okay";
    bme280@76 {
        compatible = "bosch,bme280";
        reg = <0x76>;
        label = "BME280";
    };
};

Configuration (prj.conf)

CONFIG_I2C=y
CONFIG_SENSOR=y
CONFIG_CBPRINTF_FP_SUPPORT=y

Code (main.c)

#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/drivers/sensor.h>

void main(void) {
    const struct device *dev = DEVICE_DT_GET_ANY(bosch_bme280);
    
    while (1) {
        sensor_sample_fetch(dev);
        struct sensor_value temp;
        sensor_channel_get(dev, SENSOR_CHAN_AMBIENT_TEMP, &temp);
        printk("Temp: %d.%06d C\n", temp.val1, temp.val2);
        k_sleep(K_SECONDS(1));
    }
}

4. Patterns & Templates

Pattern 1: State Machine (Bare Metal)

Use case: Handling complex device logic without an OS.

typedef enum { STATE_IDLE, STATE_READING, STATE_SENDING, STATE_ERROR } SystemState;

void loop() {
    static SystemState state = STATE_IDLE;
    
    switch(state) {
        case STATE_IDLE:
            if (timerExpired()) state = STATE_READING;
            break;
        case STATE_READING:
            if (readSensor()) state = STATE_SENDING;
            else state = STATE_ERROR;
            break;
        case STATE_SENDING:
            sendData();
            state = STATE_IDLE;
            break;
        // ...
    }
}

Pattern 2: Interrupt Deferred Processing

Use case: Keeping ISRs (Interrupt Service Routines) short.

ISR: Set a flag or push data to a ring buffer. Return immediately.
Main Loop / Task: Check buffer/flag and process data (e.g., parse GPS NMEA string).
Why? Long ISRs block other interrupts and crash the system.

Pattern 3: Watchdog Feeder

Use case: Auto-reset if the system freezes.

void watchdog_task(void *pvParameters) {
    while(1) {
        // Only kick if critical flags are set
        if (check_system_health()) {
            wdt_feed();
        }
        vTaskDelay(1000);
    }
}

6. Integration Patterns

iot-engineer:

Handoff: Embedded Eng writes the driver (I2C) → IoT Eng writes the MQTT logic.
Collaboration: Power budget (how often to wake up radio).
Tools: Power Profiler.

mobile-app-developer:

Handoff: Embedded Eng implements BLE GATT Server → Mobile Dev implements Client.
Collaboration: Defining the GATT Service/Characteristic UUIDs.
Tools: nRF Connect.

cloud-architect:

Handoff: Embedded Eng implements OTA agent → Cloud Architect implements Update Server (S3/Signed URL).
Collaboration: Security token format (JWT/X.509).
Tools: AWS IoT Jobs.

FAQ

What does the embedded-systems skill do?

Expert in RTOS, bare-metal programming, and embedded Linux. Specializes in Rust for Embedded and high-reliability firmware.

How do I install embedded-systems?

Run npx skills add https://github.com/404kidwiz/claude-supercode-skills --skill embedded-systems in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/embedded-systems/ (personal) or .claude/skills/embedded-systems/ (project).

Which AI agents can use embedded-systems?

Any agent that supports the open Agent Skills format (a folder with a SKILL.md file), including Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, Windsurf, Cline, OpenCode and more.

Is embedded-systems safe to install?

No partner security audit is available yet. Skills can run commands and scripts, so read the SKILL.md and any bundled files before installing.

Who maintains embedded-systems?

It is published by 404kidwiz in 404kidwiz/claude-supercode-skills. It has 167 recorded installs.