agency-embedded-firmware-engineer

Outline target MCU and memory budget for deterministic embedded firmware development.

Updated Apr 11, 2026
One-click install
npx skills add https://github.com/omeraltn/ice_cream_website_testing --skill agency-embedded-firmware-engineer-omeraltn
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: agency-embedded-firmware-engineer
Source: https://github.com/omeraltn/ice_cream_website_testing/tree/main/.antigravity/agency-embedded-firmware-engineer
Command: npx skills add https://github.com/omeraltn/ice_cream_website_testing --skill agency-embedded-firmware-engineer-omeraltn

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill solves the challenge of building reliable, deterministic firmware for resource-constrained embedded systems, ensuring correct peripheral behavior and predictable timing.

Core Features & Use Cases

  • Design RTOS task architectures that avoid priority inversion and deadlocks for reliable real-time behavior.
  • Implement production-grade peripheral drivers (UART, SPI, I2C, CAN, BLE, Wi-Fi) with safe error handling and non-blocking patterns.
  • Provide platform-specific guidance (ESP-IDF, STM32 LL/HAL, Zephyr/Nordic) to ensure maintainability and testability across MCU families.

Quick Start

Start by outlining the target MCU, memory budget, and required peripherals, then implement a minimal, deterministic RTOS task pattern and a basic peripheral driver skeleton.

Frequently Asked Questions about agency-embedded-firmware-engineer

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I design an RTOS task architecture that avoids priority inversion on STM32 or ESP32?

To design an RTOS task architecture avoiding priority inversion, outline your target MCU and memory budget first, then apply deterministic task patterns with proper stack sizing and safety-critical error handling to ensure predictable real-time behavior.

What's the best way to implement non-blocking ISRs in production-grade embedded firmware?

The best way to implement non-blocking ISRs in embedded firmware is to apply platform-specific conventions across ESP-IDF, STM32, or Nordic platforms, satisfying static analysis requirements and keeping interrupt service routines deterministic for constrained devices.

Does this embedded firmware approach work with ESP-IDF, STM32 HAL, and Nordic platforms?

Yes, this embedded firmware approach works with ESP-IDF, STM32 LL/HAL, and Zephyr/Nordic platforms, providing platform-specific guidance to ensure maintainability, testability, and robust peripheral driver implementation across different MCU families.

How do I build robust peripheral drivers for UART, SPI, and I2C with safe error handling?

To build robust peripheral drivers for UART, SPI, and I2C with safe error handling, implement non-blocking patterns and apply safety-critical error handling protocols tailored to your specific MCU family to ensure production-grade reliability.

Why does my RTOS firmware deadlock and how can static analysis help prevent it on constrained devices?

RTOS firmware deadlocks on constrained devices often stem from poorly structured task synchronization; applying static analysis and proper stack sizing during the design phase helps identify and prevent these timing and resource conflicts early.