Skip to main content
skill CX Codex

resource-optimization-lowend — Claude Code skill

The resource-optimization-lowend skill helps trim flash and RAM use in MCU firmware, inspect linker maps, and measure stack depth when embedded resources are tight.

MIT 376 installs ★ 298 updated 2026-06-27

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add mohitmishra786/low-level-dev-skills --skill resource-optimization-lowend -a claude-code
Open on GitHub

What resource-optimization-lowend does

The skill guides an agent through firmware size checks, symbol ranking, and detection of unexpected library pulls. Its workflow uses arm-none-eabi-size, arm-none-eabi-objdump, nm, linker map inspection, and GCC options such as -Os, --gc-sections, and -flto.

It also covers stack and memory sections: .bss, .data, heap, and stack. The agent can inspect .su files, a runtime high-water mark, uxTaskGetStackHighWaterMark, and the choice between -Os and -O2 for a hot path. LTO can fail when objects were built with different GCC versions.

The skill targets bare-metal firmware and small RTOS images. It is available for Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, and OpenCode.

What it helps with

  • find the largest flash consumers in firmware.map
  • reduce RAM use across .bss, .data, heap, and stack
  • measure stack depth and locate overflow risks
  • choose -Os or -O2 for a hot code path
  • remove unused sections with --gc-sections

Example prompts for the agent

  • Run /resource-optimization-lowend and find the largest flash consumers in firmware.map.
  • Inspect the firmware’s .rodata and .bss growth and suggest code changes.
  • Check stack usage from .su files and uxTaskGetStackHighWaterMark.

How to install resource-optimization-lowend

1Skills CLI (Vercel)

npx skills add mohitmishra786/low-level-dev-skills --skill resource-optimization-lowend -a claude-code

2Manually: put the files in place

~/.claude/skills/resource-optimization-lowend/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/resource-optimization-lowend/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about resource-optimization-lowend

How do I install resource-optimization-lowend in Claude Code?

Run npx skills add mohitmishra786/low-level-dev-skills --skill resource-optimization-lowend -a claude-code, then check ~/.claude/skills/resource-optimization-lowend/SKILL.md.

What does resource-optimization-lowend do?

It helps analyze firmware size, linker maps, RAM sections, and stack depth, then guides compiler and linker tuning for MCUs.

Which platforms support this skill?

It is intended for Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, and OpenCode.

Source text

SKILL.md · MIT
---
name: resource-optimization-lowend
description: Resource optimization skill for constrained embedded targets. Use when reducing flash/RAM usage, analyzing stack depth, reading linker map files, or tuning size vs speed on MCUs. Activates on queries about firmware size optimization, linker map, stack usage, -Os, flash RAM budget, or bloat analysis.
---

# Resource Optimization (Low-End Systems)

## Purpose

Guide agents through flash and RAM optimization on constrained devices: compiler size flags, linker map analysis, stack usage measurement, dead code elimination, and size-vs-speed tradeoffs — for bare-metal and small RTOS images.

## When to Use

- Firmware exceeds flash budget
- Stack overflow in production only
- Choosing `-Os` vs `-O2` on MCU
- Finding unexpected `.rodata` or `.bss` growth

## Workflow

### 1. Size measurement toolchain

```bash
arm-none-eabi-size -A firmware.elf
arm-none-eabi-objdump -h firmware.elf
nm --size-sort -S firmware.elf | tail -20
```

### 2. Linker map file

```ld
/* linker.ld */
OUTPUT_FORMAT("elf32-littlearm")
ENTRY(Reset_Handler)

SECTIONS
{
  /* ... */
}

/* Generate map */
/* gcc ... -Wl,-Map=firmware.map */
```

```bash
grep -E '\.text|\.rodata|\.data|\.bss' firmware.map | head
```

Identify largest symbols and unexpected library pull-in.

### 3. Compiler flags

| Flag | Effect |
|------|--------|
| `-Os` | Size-first optimization |
| `-ffunction-sections -fdata-sections` | Per-symbol sections |
| `-Wl,--gc-sections` | Drop unused sections |
| `-flto` | Cross-TU dead code elimination |
| `-specs=nano.specs` | Smaller newlib (GCC ARM) |

```makefile
CFLAGS += -Os -ffunction-sections -fdata-sections
LDFLAGS += -Wl,--gc-sections -Wl,--print-memory-usage
```

### 4. Stack analysis

```bash
# Static (if built with -fstack-usage)
find . -name '*.su' -exec cat {} \;

# Linker stack symbol
grep _estack firmware.map
```

Runtime: fill stack with pattern (`0xDEADBEEF`), run tests, scan high-water mark. FreeRTOS: `uxTaskGetStackHighWaterMark`.

### 5. RAM categories

| Section | Tactic |
|---------|--------|
| `.bss` | Shrink buffers; pool allocators |
| `.data` | Move const to flash (`const` → `.rodata`) |
| Heap | Avoid malloc; fixed pools |
| Stack | Reduce nesting; smaller ISR stacks |

### 6. Size vs speed decision

```
Hot path in ISR or 1 kHz loop?
├── Yes → -O2 for that file (#pragma GCC optimize)
└── No  → -Os globally
```

### 7. Agent usage

```
/resource-optimization-lowend Find top 10 flash consumers in firmware.map and suggest -gc-sections fixes
```

## Common Problems

| Symptom | Cause | Fix |
|---------|-------|-----|
| printf pulls 20+ KB | Full newlib printf | `_write` retarget; tiny printf |
| `--gc-sections` broke IRQ | Section collected | `KEEP()` in linker script |
| Stack overflow late | Deep call + IRQ nest | Measure HW stack; increase `_estack` |
| RAM zero but big ELF | `.data` not loaded | Check VMA/LMA |
| LTO link fail | Mixed compiler versions | Same GCC for all objects |

## Related Skills

- `skills/embedded/linker-scripts` — MEMORY/Sections layout
- `skills/baremetal/baremetal-startup` — stack symbol
- `skills/baremetal/low-power-embedded` — RAM retention
- `skills/compilers/gcc` — optimization flags
- `skills/rust/rust-no-std` — embedded Rust size patterns

© mohitmishra786 · MIT · mohitmishra786/low-level-dev-skills

Similar skills

All skills for Programming languages →

From the same set140

The whole set →
peripherals-from-datasheet peripherals-from-datasheet guides driver development directly from MCU reference manuals. Helpful when writing bare-metal register code without a vendor HAL or migrating peripherals across chips. CX Codex +1 380installs platform-device-model The platform-device-model skill explains Linux platform-driver binding, probe and remove, sysfs, device properties, and deferred probing for kernel work. CX Codex +1 378installs writing-char-drivers writing-char-drivers — a skill for writing Linux character drivers: cdev registration, file_operations implementation, safe userspace copies, ioctl and mmap. CX Codex +1 378installs adc-dac-baremetal adc-dac-baremetal — a skill for bare-metal ADC and DAC setup on MCUs: channel selection, sampling time, calibration, DMA buffers, and voltage output. Essential when working with analog sensors, audio signals, or control voltages. CX Codex +1 378installs llvm-passes llvm-passes guides coding agents in creating, building, and verifying LLVM optimization passes with the New Pass Manager. CX Codex +1 373installs openmp Teaches the agent to write and fix OpenMP code: parallel loops, reductions, tasks, SIMD hints and GPU offload. CX Codex +1 371installs numa-programming Skill teaches the agent NUMA programming: detect topology with numactl and lstopo, bind processes to local memory, use libnuma API, build per-node data structures, and diagnose remote access penalties. CX Codex +1 369installs dpdk Skill for DPDK work: EAL init, poll-mode driver setup, mbuf pools, rte_ring, huge pages, RSS, and testpmd validation. CX Codex +1 369installs

Project sponsors

Companies that keep this analytics open