Skip to content
Back to search

low-level-dev-skills

A curated suite of AI agent skills for systems and low-level programming with C/C++, Rust, and Zig toolchains, covering compilers, debuggers, profilers, build systems, sanitizers, and binary analysis

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/mohitmishra786/low-level-dev-skills with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/mohitmishra786/low-level-dev-skills'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/mohitmishra786-low-level-dev-skills/badge.svg)](/listings/mohitmishra786-low-level-dev-skills)

HTML

<a href="/listings/mohitmishra786-low-level-dev-skills"><img src="/api/listings/mohitmishra786-low-level-dev-skills/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Install all skills with a single command:

npx skills add mohitmishra786/low-level-dev-skills --all

Or select specific skills interactively:

npx skills add mohitmishra786/low-level-dev-skills

Install globally to make skills available in all projects:

npx skills add mohitmishra786/low-level-dev-skills --all --global

Install by language / tag

Install specific skill bundles using the `--skill` flag (space-separated list):

# C/C++ toolchain (compilers, debuggers, build systems, profilers)
npx skills add mohitmishra786/low-level-dev-skills --skill gcc clang llvm msvc-cl cross-gcc pgo cmake make ninja meson conan-vcpkg static-analysis gdb lldb core-dumps linux-perf valgrind flamegraphs strace-ltrace heaptrack sanitizers fuzzing elf-inspection linkers-lto binutils dynamic-linking assembly-x86 assembly-arm interpreters simd-intrinsics memory-model cpu-cache-opt

# Rust bundle (compiler, Cargo, debugging, profiling, FFI, cross, sanitizers, async, security)
npx skills add mohitmishra786/low-level-dev-skills --skill rustc-basics cargo-workflows rust-debugging rust-profiling rust-ffi rust-cross rust-sanitizers-miri rust-unsafe rust-async-internals rust-security rust-no-std rust-build-times

# Zig bundle (compiler, build system, C interop, debugging, cross, testing, comptime)
npx skills add mohitmishra786/low-level-dev-skills --skill zig-compiler zig-build-system zig-cinterop zig-debugging zig-cross zig-testing zig-comptime

# Embedded (RTOS, OpenOCD, linker scripts, embedded Rust, bare-metal)
npx skills add mohitmishra786/low-level-dev-skills --skill freertos zephyr openocd-jtag linker-scripts embedded-rust baremetal-startup mmio-and-bit-manipulation interrupts-and-exceptions-baremetal gpio-baremetal uart-serial-baremetal spi-i2c-baremetal dma-baremetal stm32-baremetal low-power-embedded

# Bare-metal focused
npx skills add mohitmishra786/low-level-dev-skills --skill baremetal-startup mmio-and-bit-manipulation interrupts-and-exceptions-baremetal peripherals-from-datasheet gpio-baremetal uart-serial-baremetal spi-i2c-baremetal timers-pwm-baremetal adc-dac-baremetal dma-baremetal stm32-baremetal datasheet-and-refmanual-reading bootloaders-embedded low-power-embedded

# Kernel & driver development
npx skills add mohitmishra786/low-level-dev-skills --skill linux-kernel-architecture kernel-memory-management kernel-concurrency device-tree platform-device-model writing-char-drivers bus-drivers-i2c-spi kernel-debugging-advanced qemu-for-kernel-development kernel-internals device-drivers

# Computer architecture
npx skills add mohitmishra786/low-level-dev-skills --skill cpu-pipelines-and-hazards memory-hierarchy-and-caches virtual-memory-paging-and-tlb abi-and-calling-conventions branch-prediction-and-speculation

# QEMU & constrained-systems tooling
npx skills add mohitmishra786/low-level-dev-skills --skill qemu-embedded-simulation qemu-for-kernel-development protocol-analysis resource-optimization-lowend verilog-basics-for-lowlevel

# Observability (eBPF, binary hardening)
npx skills add mohitmishra786/low-level-dev-skills --skill ebpf ebpf-rust binary-hardening

# WebAssembly
npx skills add mohitmishra786/low-level-dev-skills --skill wasm-emscripten wasm-wasmtime

# The core essentials (compiler + debugger + profiler for all languages)
npx skills add mohitmishra786/low-level-dev-skills --skill gcc clang rustc-basics zig-compiler gdb lldb linux-perf cmake cargo-workflows zig-build-system

# Build systems only
npx skills add mohitmishra786/low-level-dev-skills --skill cmake make ninja meson conan-vcpkg static-analysis zig-build-system cargo-workflows build-acceleration bazel include-what-you-use

# Profilers and performance tools
npx skills add mohitmishra786/low-level-dev-skills --skill linux-perf valgrind flamegraphs strace-ltrace heaptrack rust-profiling intel-vtune-amd-uprof hardware-counters

# Runtime safety (sanitizers, fuzzing, Miri, binary hardening)

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 528 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # low-level-dev-skills
  2. A curated suite of AI agent skills for systems and low-level programming — C/C++, Rust, Zig, GPU, bare-metal firmware, Linux kernel/driver development, computer architecture, compiler internals, HPC, and more. These skills provide expert guidance for compilers, debuggers, profilers, build systems, sanitizers, low-level programming, embedded development, observability, virtualization, security, and WebAssembly.
  3. **[View on skills.sh](https://skills.sh/mohitmishra786/low-level-dev-skills)**
  4. ## Installation
  5. Install all skills with a single command:
  6. ```bash
  7. npx skills add mohitmishra786/low-level-dev-skills --all
  8. ```
  9. Or select specific skills interactively:
  10. ```bash
  11. npx skills add mohitmishra786/low-level-dev-skills
  12. ```
  13. Install globally to make skills available in all projects:
  14. ```bash
  15. npx skills add mohitmishra786/low-level-dev-skills --all --global
  16. ```
  17. ### Install by language / tag
  18. Install specific skill bundles using the `--skill` flag (space-separated list):
  19. ```bash
  20. # C/C++ toolchain (compilers, debuggers, build systems, profilers)
  21. npx skills add mohitmishra786/low-level-dev-skills --skill gcc clang llvm msvc-cl cross-gcc pgo cmake make ninja meson conan-vcpkg static-analysis gdb lldb core-dumps linux-perf valgrind flamegraphs strace-ltrace heaptrack sanitizers fuzzing elf-inspection linkers-lto binutils dynamic-linking assembly-x86 assembly-arm interpreters simd-intrinsics memory-model cpu-cache-opt
  22. # Rust bundle (compiler, Cargo, debugging, profiling, FFI, cross, sanitizers, async, security)
  23. npx skills add mohitmishra786/low-level-dev-skills --skill rustc-basics cargo-workflows rust-debugging rust-profiling rust-ffi rust-cross rust-sanitizers-miri rust-unsafe rust-async-internals rust-security rust-no-std rust-build-times
  24. # Zig bundle (compiler, build system, C interop, debugging, cross, testing, comptime)
  25. npx skills add mohitmishra786/low-level-dev-skills --skill zig-compiler zig-build-system zig-cinterop zig-debugging zig-cross zig-testing zig-comptime
  26. # Embedded (RTOS, OpenOCD, linker scripts, embedded Rust, bare-metal)
  27. npx skills add mohitmishra786/low-level-dev-skills --skill freertos zephyr openocd-jtag linker-scripts embedded-rust baremetal-startup mmio-and-bit-manipulation interrupts-and-exceptions-baremetal gpio-baremetal uart-serial-baremetal spi-i2c-baremetal dma-baremetal stm32-baremetal low-power-embedded
  28. # Bare-metal focused
  29. npx skills add mohitmishra786/low-level-dev-skills --skill baremetal-startup mmio-and-bit-manipulation interrupts-and-exceptions-baremetal peripherals-from-datasheet gpio-baremetal uart-serial-baremetal spi-i2c-baremetal timers-pwm-baremetal adc-dac-baremetal dma-baremetal stm32-baremetal datasheet-and-refmanual-reading bootloaders-embedded low-power-embedded
  30. # Kernel & driver development
  31. npx skills add mohitmishra786/low-level-dev-skills --skill linux-kernel-architecture kernel-memory-management kernel-concurrency device-tree platform-device-model writing-char-drivers bus-drivers-i2c-spi kernel-debugging-advanced qemu-for-kernel-development kernel-internals device-drivers
  32. # Computer architecture
  33. npx skills add mohitmishra786/low-level-dev-skills --skill cpu-pipelines-and-hazards memory-hierarchy-and-caches virtual-memory-paging-and-tlb abi-and-calling-conventions branch-prediction-and-speculation
  34. # QEMU & constrained-systems tooling
  35. npx skills add mohitmishra786/low-level-dev-skills --skill qemu-embedded-simulation qemu-for-kernel-development protocol-analysis resource-optimization-lowend verilog-basics-for-lowlevel
  36. # Observability (eBPF, binary hardening)
  37. npx skills add mohitmishra786/low-level-dev-skills --skill ebpf ebpf-rust binary-hardening
  38. # WebAssembly
  39. npx skills add mohitmishra786/low-level-dev-skills --skill wasm-emscripten wasm-wasmtime
  40. # The core essentials (compiler + debugger + profiler for all languages)
  41. npx skills add mohitmishra786/low-level-dev-skills --skill gcc clang rustc-basics zig-compiler gdb lldb linux-perf cmake cargo-workflows zig-build-system
  42. # Build systems only
  43. npx skills add mohitmishra786/low-level-dev-skills --skill cmake make ninja meson conan-vcpkg static-analysis zig-build-system cargo-workflows build-acceleration bazel include-what-you-use
  44. # Profilers and performance tools
  45. npx skills add mohitmishra786/low-level-dev-skills --skill linux-perf valgrind flamegraphs strace-ltrace heaptrack rust-profiling intel-vtune-amd-uprof hardware-counters
  46. # Runtime safety (sanitizers, fuzzing, Miri, binary hardening)
  47. npx skills add mohitmishra786/low-level-dev-skills --skill sanitizers fuzzing rust-sanitizers-miri rust-unsafe binary-hardening rust-security
  48. # Binary analysis (ELF, linkers, dynamic linking, binutils, DWARF)
  49. npx skills add mohitmishra786/low-level-dev-skills --skill elf-inspection linkers-lto binutils dynamic-linking dwarf-debug-format
  50. # GPU programming (CUDA, Triton, ROCm, memory model)
  51. npx skills add mohitmishra786/low-level-dev-skills --skill cuda cuda-profiling cuda-debugging triton-lang hip-rocm gpu-memory-model
  52. # Kernel internals and drivers
  53. npx skills add mohitmishra786/low-level-dev-skills --skill kernel-internals device-drivers kernel-debugging kernel-testing os-dev-scratch
  54. # Async I/O and kernel bypass networking
  55. npx skills add mohitmishra786/low-level-dev-skills --skill io-uring dpdk af-xdp
  56. # Allocators and NUMA
  57. npx skills add mohitmishra786/low-level-dev-skills --skill custom-allocators numa-programming
  58. # Compiler internals (frontend, IR, passes, codegen, MLIR, JIT)
  59. npx skills add mohitmishra786/low-level-dev-skills --skill compiler-frontend llvm-passes llvm-ir-and-passes compiler-optimizations-deep code-generation-and-backends mlir jit-compilation
  60. # Virtualization
  61. npx skills add mohitmishra786/low-level-dev-skills --skill qemu-kvm hypervisor-internals containers-internals
  62. # HPC and parallel programming
  63. npx skills add mohitmishra786/low-level-dev-skills --skill openmp mpi rdma-verbs
  64. # Security and reverse engineering
  65. npx skills add mohitmishra786/low-level-dev-skills --skill reverse-engineering kernel-security
  66. # Platform-specific (ARM SVE, RISC-V privileged, Apple Silicon)
  67. npx skills add mohitmishra786/low-level-dev-skills --skill arm-sve riscv-privileged apple-silicon
  68. # Emerging languages (Carbon, Hare)
  69. npx skills add mohitmishra786/low-level-dev-skills --skill carbon-lang hare-lang
  70. ```
  71. ## Supported Agents
  72. Skills work with 30+ AI coding agents:
  73. | Agent | Skill Directory |
  74. |-------|-----------------|
  75. | [Claude Code](https://claude.com/product/claude-code) | `.claude/skills/` |
  76. | [Cursor](https://cursor.sh) | `.cursor/skills/` |
  77. | [Codex](https://openai.com/codex) | `.codex/skills/` |
  78. | [GitHub Copilot](https://github.com/features/copilot) | `.github/copilot/skills/` |
  79. | [Cline](https://cline.bot) | `.cline/skills/` |
  80. | [Windsurf](https://codeium.com/windsurf) | `.windsurf/skills/` |
  81. | [Gemini CLI](https://gemini.google.com) | `.gemini/skills/` |
  82. | [Kilo](https://kilo.ai) | `.kilo/skills/` |
  83. And many more including: Amp, Antigravity, Augment, Droid, Goose, Kiro CLI, OpenCode, Roo, Trae, VSCode, and others.
  84. ## Usage Examples
  85. After installation, invoke skills in your AI agent:
  86. ### C/C++ toolchain
  87. ```
  88. /gcc How do I enable link-time optimization?
  89. /gdb Set a conditional breakpoint in GDB
  90. /cmake What's the modern way to find packages?
  91. /static-analysis Run clang-tidy on my whole project
  92. /pgo Walk me through a GCC PGO workflow
  93. /dynamic-linking My binary can't find its shared library
  94. /cpp-modules How do I write a C++20 named module?
  95. /cpp-templates How do I use concepts as constraints?
  96. /binary-hardening How do I add RELRO and PIE to my binary?
  97. ```
  98. ### Rust
  99. ```
  100. /rustc-basics Configure a release build for maximum performance
  101. /cargo-workflows Set up a Cargo workspace with multiple crates
  102. /rust-debugging Debug a Rust panic with GDB
  103. /rust-profiling Generate a flamegraph for my Rust binary
  104. /rust-ffi Generate bindings to a C library with bindgen
  105. /rust-cross Cross-compile Rust for ARM with cargo-zigbuild
  106. /rust-async-internals Debug a waker leak in my async code
  107. /rust-security Audit my dependencies with cargo-deny
  108. /rust-no-std Set up a no_std crate for embedded
  109. /rust-build-times Speed up my Rust workspace compilation
  110. ```
  111. ### Zig
  112. ```
  113. /zig-compiler What optimization mode should I use?
  114. /zig-build-system Add a C library to my build.zig
  115. /zig-cinterop Call a C function from Zig using @cImport
  116. /zig-cross Cross-compile Zig for Raspberry Pi
  117. /zig-testing How do I detect memory leaks in Zig tests?
  118. /zig-comptime Write a generic Stack using comptime
  119. ```
  120. ### Embedded and bare-metal
  121. ```
  122. /freertos How do I detect stack overflow in FreeRTOS?
  123. /zephyr Build and flash a Zephyr app with west
  124. /openocd-jtag Connect GDB to my STM32 via OpenOCD
  125. /linker-scripts Place my code in CCM RAM with a linker script
  126. /embedded-rust Flash and debug with probe-rs and defmt
  127. /baremetal-startup Fix .bss init so globals are zero before main
  128. /stm32-baremetal Scaffold CMSIS-only STM32F4 without HAL
  129. /bootloaders-embedded Jump from bootloader to app at 0x08010000
  130. ```
  131. ### Kernel drivers and architecture
  132. ```
  133. /linux-kernel-architecture Where does the page fault handler live?
  134. /device-tree Write a DTS node for an I2C sensor with interrupt
  135. /writing-char-drivers Add ioctl to my platform driver
  136. /cpu-pipelines-and-hazards Break a RAW hazard in this hot loop
  137. /llvm-ir-and-passes Explain what -O2 changed in this LLVM IR
  138. /qemu-embedded-simulation Run my Cortex-M firmware in QEMU with GDB
  139. ```
  140. ### Observability and security
  141. ```
  142. /ebpf Write a bpftrace one-liner to trace system calls
  143. /ebpf-rust Write an eBPF program in Rust with Aya
  144. /binary-hardening Check my binary with checksec
  145. /wasm-emscripten Compile my C library to WebAssembly
  146. /wasm-wasmtime Embed wasmtime in my Rust application
  147. ```
  148. ### Profiling & analysis
  149. ```
  150. /linux-perf Generate a flame graph from perf data
  151. /strace-ltrace Trace system calls to find a missing config file
  152. /sanitizers Which sanitizer should I use for memory leaks?
  153. /valgrind How do I suppress known false positives?
  154. /heaptrack Find allocation hotspots in my C++ server
  155. /intel-vtune-amd-uprof Analyze pipeline stalls in my hot function
  156. /hardware-counters Measure cache miss rate with perf stat
  157. ```
  158. ### Advanced debugging
  159. ```
  160. /concurrency-debugging Read a TSan data race report
  161. /debug-optimized-builds Why does GDB say "value optimized out"?
  162. /dwarf-debug-format Set up debuginfod for automatic symbols
  163. ```
  164. ### GPU and HPC
  165. ```
  166. /cuda How do I fix warp divergence in my kernel?
  167. /cuda-profiling Is my kernel memory-bound or compute-bound?
  168. /openmp Parallelize this loop with a dynamic schedule
  169. /mpi Debug a deadlock in my MPI_Send/Recv pattern
  170. ```
  171. ### Kernel and systems
  172. ```
  173. /kernel-internals Interpret /proc/meminfo during memory pressure
  174. /device-drivers Write a platform_driver with threaded IRQs
  175. /io-uring Build a server with liburing multi-shot accept
  176. /qemu-kvm Boot my custom kernel with -kernel -append
  177. ```
  178. ### Security and platform
  179. ```
  180. /reverse-engineering Triage this stripped ELF with Ghidra
  181. /kernel-security Write an AppArmor profile for my daemon
  182. /arm-sve Write a vector-length agnostic SAXPY kernel
  183. /apple-silicon Profile my app with Instruments on M-series
  184. ```
  185. ## Skills
  186. ### C/C++ Compilers (8 skills)
  187. | Skill | Purpose |
  188. |-------|---------|
  189. | `gcc` | GCC flags, optimization levels, warnings, diagnostics |
  190. | `clang` | Clang/LLVM tooling, diagnostics, sanitizer integration |
  191. | `llvm` | LLVM IR, passes, opt/llc pipeline |
  192. | `msvc-cl` | MSVC cl.exe and clang-cl, Windows toolchain |
  193. | `cross-gcc` | Cross-compilation triplets, sysroots, embedded targets |
  194. | `pgo` | Profile-guided optimization — GCC, Clang, BOLT |
  195. | `cpp-modules` | C++20 modules: named modules, header units, CMake integration |
  196. | `cpp-templates` | Template error reading, concepts, requires-clauses, Templight |
  197. ### Debuggers (6 skills)
  198. | Skill | Purpose |
  199. |-------|---------|
  200. | `gdb` | GDB sessions, breakpoints, reverse debug, remote debug |
  201. | `lldb` | LLDB commands, GDB migration, IDE integration |
  202. | `core-dumps` | Core file analysis, debuginfod, production crash triage |
  203. | `concurrency-debugging` | TSan reports, deadlock triage, happens-before reasoning |
  204. | `debug-optimized-builds` | RelWithDebInfo, -Og, inlined frames, "value optimized out" |
  205. | `dwarf-debug-format` | DWARF sections, dwarfdump, split DWARF, debuginfod |
  206. ### Profilers (7 skills)
  207. | Skill | Purpose |
  208. |-------|---------|
  209. | `linux-perf` | perf record/report, flame data, kernel symbols |
  210. | `valgrind` | memcheck, cachegrind, suppression files |
  211. | `flamegraphs` | perf-to-SVG pipeline, reading frames |
  212. | `strace-ltrace` | Syscall and library call tracing, ENOENT/EPERM triage |
  213. | `heaptrack` | Heap allocation profiling, leak detection, hotspots |
  214. | `intel-vtune-amd-uprof` | VTune hotspots, microarchitecture analysis, roofline model |
  215. | `hardware-counters` | perf stat -e, PAPI, cache miss rates, IPC analysis |
  216. ### Build Systems (9 skills)
  217. | Skill | Purpose |
  218. |-------|---------|
  219. | `make` | Idiomatic Makefiles, pattern rules, dep generation |
  220. | `cmake` | Modern CMake, targets-first, toolchain files |
  221. | `ninja` | Ninja diagnosis, parallelism, CMake integration |
  222. | `meson` | Meson setup, wrap system, cross-compilation |
  223. | `static-analysis` | clang-tidy, cppcheck, scan-build — triage workflow |
  224. | `conan-vcpkg` | C/C++ package management with Conan and vcpkg |
  225. | `build-acceleration` | ccache, sccache, unity builds, PCH, split-DWARF |
  226. | `bazel` | BUILD files, cc_library/cc_binary, remote execution, Bzlmod |
  227. | `include-what-you-use` | IWYU with CMake, reports, forward declarations |
  228. ### Binary Analysis (4 skills)
  229. | Skill | Purpose |
  230. |-------|---------|
  231. | `elf-inspection` | readelf, objdump, nm, ldd, section analysis |
  232. | `linkers-lto` | GNU ld/gold/lld, -flto, link order, symbol issues |
  233. | `binutils` | ar, strip, objcopy, addr2line workflows |
  234. | `dynamic-linking` | dlopen, RPATH/RUNPATH, soname versioning, LD_PRELOAD |
  235. ### Runtime Safety (6 skills)
  236. | Skill | Purpose |
  237. |-------|---------|
  238. | `sanitizers` | ASan/UBSan/TSan/MSan decision trees and report triage |
  239. | `fuzzing` | libFuzzer/AFL, corpus, CI integration |
  240. | `binary-hardening` | checksec, RELRO, PIE, CFI, shadow stack, seccomp-bpf |
  241. | `wasm-emscripten` | emcc flags, EXPORTED_FUNCTIONS, memory model, Asyncify |
  242. | `wasm-wasmtime` | wasmtime CLI, WASI preview2, component model, Rust embedding |
  243. ### Low-Level Programming (9 skills)
  244. | Skill | Purpose |
  245. |-------|---------|
  246. | `assembly-x86` | x86-64 AT&T/Intel syntax, calling conventions, inline asm |
  247. | `assembly-arm` | AArch64/ARM Thumb, AAPCS, inline asm |
  248. | `assembly-riscv` | RV32/RV64 ISA, psABI, inline asm, QEMU simulation |
  249. | `interpreters` | Bytecode VMs, dispatch loops, JIT fundamentals |
  250. | `simd-intrinsics` | SSE2/AVX2/NEON intrinsics, auto-vectorization reports |
  251. | `memory-model` | C++/Rust memory orderings, acquire-release, lock-free patterns |
  252. | `cpu-cache-opt` | Cache misses, AoS vs SoA, false sharing, prefetching |
  253. | `cpp-coroutines` | co_await/co_yield/co_return, promise_type, frame layout, GDB |
  254. | `linux-kernel-modules` | LKMs, Kbuild, /proc, sysfs, char devices, KGDB |
  255. ### Observability (2 skills)
  256. | Skill | Purpose |
  257. |-------|---------|
  258. | `ebpf` | bpftool, libbpf, bpftrace, verifier errors, XDP, CO-RE |
  259. | `ebpf-rust` | Aya framework, aya-bpf, aya-log, map sharing, tokio integration |
  260. ### Embedded (5 skills)
  261. | Skill | Purpose |
  262. |-------|---------|
  263. | `freertos` | Tasks, queues, mutexes, stack overflow detection, GDB debugging |
  264. | `zephyr` | west build, Kconfig, devicetree, logging, native_sim target |
  265. | `openocd-jtag` | OpenOCD config, flash programming, GDB remote, JTAG vs SWD |
  266. | `linker-scripts` | MEMORY/SECTIONS, VMA vs LMA, .bss/.data init, weak symbols |
  267. | `embedded-rust` | probe-rs, cargo-embed, defmt, RTIC, cortex-m-rt, no_std |
  268. ### Bare-Metal (14 skills)
  269. | Skill | Purpose |
  270. |-------|---------|
  271. | `baremetal-startup` | Reset vector, .data/.bss, stack, crt0, Cortex-M/RISC-V bring-up |
  272. | `mmio-and-bit-manipulation` | volatile MMIO, RMW, alignment, endianness, register masks |
  273. | `interrupts-and-exceptions-baremetal` | NVIC, ISRs, priority, HardFault, latency |
  274. | `peripherals-from-datasheet` | Driver methodology from reference manual register maps |
  275. | `gpio-baremetal` | Pin modes, AF mux, EXTI — STM32, nRF, ESP32 patterns |
  276. | `uart-serial-baremetal` | Polling and IRQ UART, baud, framing, DMA basics |
  277. | `spi-i2c-baremetal` | Master transactions, register read/write protocols |
  278. | `timers-pwm-baremetal` | Timer config, PWM, input capture, output compare |
  279. | `adc-dac-baremetal` | Sampling, calibration, DMA, DAC output |
  280. | `dma-baremetal` | Channel setup, memory/peripheral transfers, IRQ completion |
  281. | `stm32-baremetal` | CMSIS-only STM32 project layout without HAL |
  282. | `datasheet-and-refmanual-reading` | Fast extraction from DS/RM, errata, pin tables |
  283. | `bootloaders-embedded` | VTOR relocation, app validation, OTA/DFU basics |
  284. | `low-power-embedded` | Sleep/stop/standby, clock gating, wake sources |
  285. ### Kernel & Driver Development (9 skills)
  286. | Skill | Purpose |
  287. |-------|---------|
  288. | `linux-kernel-architecture` | Subsystems, boot flow, initcalls, source navigation |
  289. | `kernel-memory-management` | Buddy, SLUB, kmalloc, vmalloc, zones, OOM |
  290. | `kernel-concurrency` | Spinlocks, mutex, RCU, seqlock, barriers |
  291. | `device-tree` | DTS syntax, bindings, phandles, overlays |
  292. | `platform-device-model` | platform_driver, probe/remove, sysfs, deferred probe |
  293. | `writing-char-drivers` | file_operations, cdev, copy_to/from_user, ioctl, mmap |
  294. | `bus-drivers-i2c-spi` | i2c_driver, spi_driver, regmap client drivers |
  295. | `kernel-debugging-advanced` | ftrace, trace-cmd, kprobes, kgdb, vmcore |
  296. | `qemu-for-kernel-development` | QEMU + rootfs for kernel/module iteration |
  297. ### Computer Architecture (5 skills)
  298. | Skill | Purpose |
  299. |-------|---------|
  300. | `cpu-pipelines-and-hazards` | Pipeline stages, RAW hazards, forwarding, stalls |
  301. | `memory-hierarchy-and-caches` | L1/L2/L3, coherence, false sharing, prefetch |
  302. | `virtual-memory-paging-and-tlb` | Page tables, faults, TLB pressure, huge pages |
  303. | `abi-and-calling-conventions` | SysV AMD64, AAPCS, RISC-V psABI, stack frames |
  304. | `branch-prediction-and-speculation` | Predictors, mispredict, Spectre/Meltdown awareness |
  305. ### QEMU & Constrained Systems (4 skills)
  306. | Skill | Purpose |
  307. |-------|---------|
  308. | `qemu-embedded-simulation` | Bare-metal ARM/RISC-V in QEMU, -kernel, GDB |
  309. | `protocol-analysis` | sigrok/PulseView I2C/SPI/UART decode |
  310. | `resource-optimization-lowend` | Flash/RAM, linker maps, stack analysis, -Os |
  311. | `verilog-basics-for-lowlevel` | Read RTL for MMIO, resets, CDC, bus interfaces |
  312. ### Rust (12 skills)
  313. | Skill | Purpose |
  314. |-------|---------|
  315. | `rustc-basics` | RUSTFLAGS, Cargo profiles, MIR/asm output, monomorphization |
  316. | `cargo-workflows` | Workspaces, features, build.rs, nextest, cargo-deny |
  317. | `rust-debugging` | rust-gdb/rust-lldb, backtraces, tokio-console, dbg! |
  318. | `rust-profiling` | cargo-flamegraph, cargo-bloat, cargo-llvm-lines, Criterion |
  319. | `rust-ffi` | bindgen, cbindgen, sys crates, safe FFI wrappers |
  320. | `rust-cross` | cross tool, cargo-zigbuild, bare-metal, no_std |
  321. | `rust-sanitizers-miri` | ASan/TSan with RUSTFLAGS, Miri for unsafe UB detection |
  322. | `rust-unsafe` | Raw pointers, transmute, UnsafeCell, audit checklist |
  323. | `rust-async-internals` | Future/poll model, Pin/Unpin, tokio-console, select!/join! |
  324. | `rust-security` | cargo-audit, cargo-deny, RUSTSEC, safe FFI, fuzzing pipeline |
  325. | `rust-no-std` | #![no_std], core vs std, alloc crate, custom allocators |
  326. | `rust-build-times` | cargo-timings, sccache, Cranelift, workspace splitting, mold |
  327. ### Zig (7 skills)
  328. | Skill | Purpose |
  329. |-------|---------|
  330. | `zig-compiler` | zig build-exe/lib, optimize modes, zig cc, error messages |
  331. | `zig-build-system` | build.zig, modules, C integration, build.zig.zon packages |
  332. | `zig-cinterop` | @cImport, translate-c, extern struct, packed struct, exports |
  333. | `zig-debugging` | GDB/LLDB with Zig, panics, error return traces, std.debug |
  334. | `zig-cross` | Built-in cross-compilation, target triples, zig cc cross, WASM |
  335. | `zig-testing` | zig build test, comptime testing, test allocators, fuzz testing |
  336. | `zig-comptime` | comptime evaluation, anytype generics, @typeInfo reflection |
  337. ### GPU (6 skills)
  338. | Skill | Purpose |
  339. |-------|---------|
  340. | `cuda` | CUDA kernels, memory hierarchy, streams, nvcc, Thrust |
  341. | `cuda-profiling` | Nsight Systems/Compute, NCU CLI, roofline diagnosis |
  342. | `cuda-debugging` | cuda-gdb, compute-sanitizer, device printf, error codes |
  343. | `triton-lang` | Triton JIT kernels, autotuning, PyTorch integration |
  344. | `hip-rocm` | AMD HIP, hipify porting, rocprof, MI300X tuning |
  345. | `gpu-memory-model` | SIMT, coalescing, bank conflicts, occupancy tradeoffs |
  346. ### Kernel Internals (5 skills)
  347. | Skill | Purpose |
  348. |-------|---------|
  349. | `kernel-internals` | Scheduler, buddy/SLUB, VFS, page cache, OOM killer |
  350. | `device-drivers` | platform/i2c/spi drivers, IRQ, DMA, regmap, udev |
  351. | `kernel-debugging` | kgdb, kdb, ftrace, kprobes, dyndbg, crash dumps |
  352. | `kernel-testing` | KUnit, kselftest, syzkaller, LTP, KernelCI |
  353. | `os-dev-scratch` | Bootloader, long mode, IDT, paging, context switch |
  354. ### Async I/O (3 skills)
  355. | Skill | Purpose |
  356. |-------|---------|
  357. | `io-uring` | liburing SQE/CQE, multi-shot, provided buffers, SEND_ZC |
  358. | `dpdk` | EAL, PMD, mbuf pools, huge pages, RSS, testpmd |
  359. | `af-xdp` | UMEM, XSK rings, XDP_REDIRECT, zero-copy packet I/O |
  360. ### Allocators (2 skills)
  361. | Skill | Purpose |
  362. |-------|---------|
  363. | `custom-allocators` | Pool/arena allocators, jemalloc/mimalloc tuning, GlobalAlloc |
  364. | `numa-programming` | numactl, libnuma, NUMA-aware structures, lstopo |
  365. ### Compiler Internals (7 skills)
  366. | Skill | Purpose |
  367. |-------|---------|
  368. | `compiler-frontend` | Lexer, Pratt parser, AST, type checker, LLVM IR emission |
  369. | `llvm-passes` | New Pass Manager, PassPlugin, llvm-lit, analysis utilities |
  370. | `llvm-ir-and-passes` | Read LLVM IR/SSA, opt pipelines, llvm-dis inspection |
  371. | `compiler-optimizations-deep` | RA, vectorization, PGO, BOLT, LICM depth |
  372. | `code-generation-and-backends` | ISel, TableGen, llc, target lowering overview |
  373. | `mlir` | Dialects, ODS, lowering passes, mlir-opt, Torch-MLIR/IREE |
  374. | `jit-compilation` | ORC JIT, LLJIT, Cranelift, inline caches, W^X policy |
  375. ### Virtualization (3 skills)
  376. | Skill | Purpose |
  377. |-------|---------|
  378. | `qemu-kvm` | KVM flags, virtio, VFIO passthrough, libvirt, kernel boot |
  379. | `hypervisor-internals` | VT-x/SVM, VMCS/VMCB, EPT/NPT, APIC virtualization |
  380. | `containers-internals` | namespaces, cgroups v2, overlayfs, runc, seccomp |
  381. ### Security (2 skills)
  382. | Skill | Purpose |
  383. |-------|---------|
  384. | `reverse-engineering` | Ghidra, radare2, Binary Ninja, stripped binary triage |
  385. | `kernel-security` | SELinux, AppArmor, seccomp, KASLR, CET, PAC/BTI, KASAN |
  386. ### HPC (3 skills)
  387. | Skill | Purpose |
  388. |-------|---------|
  389. | `openmp` | Parallel for, reductions, SIMD, task parallelism, GPU offload |
  390. | `mpi` | Send/recv, collectives, non-blocking, MPI+OpenMP hybrid |
  391. | `rdma-verbs` | libibverbs, queue pairs, RDMA read/write, RoCE, perftest |
  392. ### Platform (3 skills)
  393. | Skill | Purpose |
  394. |-------|---------|
  395. | `arm-sve` | SVE/SVE2 intrinsics, predicates, VLA loops, Graviton tuning |
  396. | `riscv-privileged` | M/S/U modes, CSRs, PLIC/CLINT, OpenSBI, Sv39/Sv48 |
  397. | `apple-silicon` | Unified memory, AMX/Accelerate, MPS, Instruments, Rosetta |
  398. ### Languages (2 skills)
  399. | Skill | Purpose |
  400. |-------|---------|
  401. | `carbon-lang` | Carbon syntax, C++ interop, carbon-toolchain, migration |
  402. | `hare-lang` | hare build/test, stdlib, C FFI, tagged union errors |
  403. **Total: 142 skills**
  404. ## Design
  405. Each skill follows the [SKILL.md format](https://github.com/anthropics/skills). The body stays under 500 lines; detailed reference material lives in `references/` and is loaded only when needed (progressive disclosure).
  406. Skills cross-reference each other where workflows overlap (e.g., `rust-profiling` + `linux-perf`, `zig-cinterop` + `zig-build-system`, `sanitizers` + `fuzzing`, `embedded-rust` + `linker-scripts`, `ebpf` + `ebpf-rust`).
  407. ## Contributing
  408. Contributions are welcome! To add or improve a skill:
  409. 1. Fork the repository
  410. 2. Create or modify skills in `skills/<category>/<skill-name>/SKILL.md`
  411. 3. Follow the SKILL.md format with required sections (Purpose, Triggers, Workflow, Related skills)
  412. 4. Add reference files in `references/` for content that exceeds 500 lines
  413. 5. Submit a pull request
  414. ## Topics
  415. `ai-agent-skills` `low-level-programming` `c-cpp-toolchain` `systems-programming` `compilers` `debuggers` `profilers` `build-systems` `rust` `zig` `embedded` `bare-metal` `cross-compilation` `ebpf` `webassembly` `freertos` `zephyr` `risc-v` `cuda` `gpu` `linux-kernel` `kernel-drivers` `computer-architecture` `qemu` `hpc` `mpi` `virtualization` `reverse-engineering`

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.