mohitmishra786/low-level-dev-skills
74 skills25.8k installs11.5k starsGitHub
Install
npx skills add https://github.com/mohitmishra786/low-level-dev-skillsSkills in this repo
1CmakeThe cmake skill guides CMake build system authoring for C and C++ projects including out-of-source build directories, generator selection among Ninja, Make, and Visual Studio, and target dependency management. It documents modern CMake target-based patterns, install rules, and fetch-content workflows agents apply when refactoring legacy CMakeLists files. Agents help configure cross-platform builds and CI-friendly generator choices. The skill triggers on CMakeLists edits, build failures, and generator migration tasks in low-level native codebases. CMakeLists.txt authoring and refactoring for C/C++. Out-of-source builds and generator selection. Ninja, Make, and Visual Studio generator guidance. Modern target-based CMake dependency patterns. CI-friendly native build configuration workflows. Write and refactor CMakeLists.txt with generators, targets, and out-of-source builds for C/C++.1.2kinstalls2Static AnalysisStatic Analysis is a mohitmishra786/low-level-dev-skills module centered on clang-tidy for C and C++ codebases. It documents high-value check groups, prominently the bugprone-* family that catches use-after-move, suspicious memset on pointers, narrowing conversions, identical if/else branches, and macro parenthesis errors. Developers reach for Static Analysis when hardening systems code, preparing PR reviews, or enabling modernization passes without manually curating hundreds of LLVM check names. The skill maps each check to concrete failure modes—integer division assigned to float, signed char as array index, and brittle string constructors—so agents recommend targeted .clang-tidy configs. Outputs include prioritized check lists, suggested NOLINT exceptions, and CI-ready clang-tidy invocation patterns for repositories using CMake or compile_commands.json.781installs3LlvmLLVM is an Agent Skill from mohitmishra786/low-level-dev-skills focused on LLVM intermediate representation for systems and compiler engineers. The skill helps coding agents produce, inspect, and tune LLVM IR when implementing language backends, JIT pipelines, or low-level runtimes where hand-written assembly is too brittle. Developers reach for LLVM when optimizing hot paths, lowering custom DSLs, or debugging IR-level performance regressions in performance-critical infrastructure. Catalog metadata lists 1 install and rank 3440 on skills.sh, reflecting a niche but specialized low-level development capability rather than general application coding.634installs4Gdbgdb is a low-level developer skill from mohitmishra786/low-level-dev-skills that guides GNU Debugger workflows for native C and C++ binaries. The skill helps developers set breakpoints, inspect stacks, read memory and registers, trace thread deadlocks, and analyze segfaults when programs crash during development or after release. Developers reach for gdb when core dumps, intermittent crashes, or corrupted state require interactive debugging beyond printf logging or sanitizer reports alone. The workflow covers launching gdb against failing binaries, capturing backtraces at fault points, stepping through suspect functions, and correlating register and heap state with source lines. Use it during bring-up of systems software, game engines, embedded firmware, or any native module where production incidents demand fast root-cause isolation.511installs5Linux Perflinux-perf is a low-level-dev-skills agent skill for CPU performance analysis with the Linux perf profiler. It walks through nine workflow sections covering prerequisites, paranoid-level sysctl tuning, compiling with -g and -fno-omit-frame-pointer, perf stat hardware counters (cache-misses, IPC, branch-misses), perf record sampling at configurable frequencies, perf report hotspot review, perf annotate disassembly, off-CPU profiling, and flamegraph handoff. The skill explains how to interpret IPC below 1.0, cache-miss rates above 5%, and branch-miss rates above 5% as optimization signals. Developers reach for linux-perf when profiling C/C++/Rust binaries on Linux, diagnosing [unknown] stack frames, or feeding perf.data into flamegraph generators before shipping latency-sensitive services.427installs6Core Dumpscore-dumps is a low-level debugging skill in mohitmishra786/low-level-dev-skills for post-crash analysis of native binaries. It walks developers through loading core files in gdb or lldb, resolving symbols, reading backtraces, and inspecting memory and registers to pinpoint segfaults and heap corruption that only surface under production load. Developers reach for core-dumps when a service dies with a core dump artifact and logs alone do not reveal the faulting frame—common in C, C++, and Rust services, game engines, and embedded runtimes. The skill emphasizes symbol table usage and debugger commands that turn opaque crash artifacts into actionable root-cause lines.425installs7Sanitizerssanitizers is a low-level development skill from mohitmishra786/low-level-dev-skills that configures AddressSanitizer (ASan), ThreadSanitizer (TSan), and UndefinedBehaviorSanitizer (UBSan) for Rust and C/C++ CI pipelines. The skill helps developers add compiler and linker flags, run sanitizer-instrumented test jobs, and interpret crash reports for heap overflows, use-after-free, data races, and undefined behavior before release. Developers reach for sanitizers when hardening native services, FFI boundaries, or performance-critical C/C++ and Rust codebases that need automated memory and concurrency defect detection in CI. It targets the gap between unit tests and production crashes caused by UB and threading bugs.415installs8Cross GccCross GCC is an agent skill from mohitmishra786/low-level-dev-skills that guides setup of GCC cross-compilers and sysroots for non-native targets. The workflow covers toolchain selection, sysroot layout, and build flags so ARM, embedded, or other foreign-architecture binaries compile from a developer machine or CI runner. Developers reach for Cross GCC when porting low-level code to embedded boards or heterogeneous build farms. Cross GCC fits teams shipping firmware, drivers, or bare-metal services that cannot rely on the host architecture compiler alone.412installs9Clangclang is a skill from mohitmishra786/low-level-dev-skills for developers working at the C/C++ and Rust boundary. It guides clang and clang++ flag selection, AddressSanitizer and UndefinedBehaviorSanitizer setup, cross-compilation triples, and clang-static-analyzer workflows when building native libraries consumed by Rust crates or standalone CLI tools. Developers reach for clang when CI builds fail on warning policies, sanitizer crashes need triage, or embedded targets require non-default toolchains. The skill focuses on compiler invocation and analysis configuration rather than rewriting application logic, making it a reference for build scripts, CMake presets, and cargo build integration with native dependencies.405installs10FreertosCovers FreeRTOS fundamentals for embedded backends: scheduling tasks, synchronizing with queues, configuring clocks, and debugging stack overflows on resource-constrained targets serving mobile peripherals and edge APIs.404installs11Gccgcc is an agent skill from mohitmishra786/low-level-dev-skills, a curated suite for systems programming across C/C++, Rust, and Zig toolchains. The skill walks agents through GCC invocations: debug builds with -g -O0 -Wall -Wextra, release -O2/-O3 profiles, link-time optimization, profile-guided optimization, and -fsanitize=address,undefined instrumentation. It covers warning triage, undefined-reference and ABI mismatch errors, preprocessor macros, and integration with GNU Make, CMake, or shell build scripts. The parent repo groups gcc among 8 dedicated C/C++ compiler skills alongside clang, llvm, cross-gcc, and pgo. Developers reach for gcc when a native build is too slow, too large, too noisy with warnings, or failing at link time—and they need concrete flag recipes instead of guessing optimization levels.393installs12Linux Kernel Moduleslinux-kernel-modules is a systems programming skill from mohitmishra786/low-level-dev-skills that guides implementation, loading, and debugging of loadable Linux kernel modules. The skill covers modules that expose char devices, netfilter hooks, sysfs entries, or custom syscalls for driver and kernel tooling work. Developers reach for linux-kernel-modules when extending the Linux kernel with `.ko` modules, wiring proc/sysfs interfaces, or debugging insmod failures and kernel oops during driver bring-up. It fits engineers working on networking filters, device drivers, and kernel-adjacent observability hooks who need correct lifecycle, licensing, and kernel API usage patterns.390installs13Assembly Armassembly-arm is a low-level-dev-skills agent skill for AArch64 and ARM Thumb assembly from the mohitmishra786 toolchain suite. The skill documents AAPCS64 register roles across x0–x7 argument slots, v0–v7 SIMD args, callee-saved x19–x28, and 16-byte stack alignment rules. Developers reach for assembly-arm when reading GCC or Clang -S output, writing inline asm in C/C++/Rust, debugging register and stack state on ARM hardware or QEMU, or applying NEON and SVE SIMD patterns in performance-critical paths.384installs14Assembly X86assembly-x86 is a low-level-dev-skills agent skill for x86-64 assembly from the mohitmishra786 toolchain suite. The skill documents System V AMD64 ABI register roles across rdi, rsi, rdx, rcx, r8, r9 argument slots, xmm0–xmm7 SIMD args, callee-saved rbx/rbp/r12–r15, and the 128-byte red zone. Developers reach for assembly-x86 when reading GCC -S output in AT&T or Intel syntax, writing inline asm in C/C++, debugging rsp/rbp stack frames in GDB, or applying SSE, AVX, and AVX-512 intrinsics in hot paths.383installs15Makemake is a skill under mohitmishra786/low-level-dev-skills/skills/build-systems/make/ that guides agents writing and debugging GNU Makefiles for C and C++ codebases. It provides a minimal correct Makefile with wildcard sources, build/%.o pattern rules, and automatic variables $@, $<, $^, then adds -MMD -MP dependency generation so header edits trigger rebuilds. The skill documents debug versus release BUILD flags, make -j$(nproc) parallel builds, install targets with PREFIX, multi-directory include patterns via module.mk files, and a seven-row common-errors table covering missing separators, circular dependencies, and full rebuilds. Developers reach for make when converting ad-hoc gcc shell scripts into maintainable native build entrypoints or diagnosing why make rebuilds everything every time.377installs16Simd Intrinsicssimd-intrinsics is a low-level performance skill from mohitmishra786/low-level-dev-skills for replacing scalar hot loops with platform-specific SIMD instructions. It covers SSE and AVX on x86 and NEON on ARM, targeting native services, codecs, and data pipelines where CPU-bound work limits throughput. The skill walks through identifying vectorizable loops, selecting the right intrinsic sets, and applying patterns that yield measurable latency and throughput improvements. Developers reach for simd-intrinsics when profiling shows tight loops dominating flame graphs and compiler auto-vectorization is insufficient. It assumes comfort with C, C++, or Rust native code and CPU architecture basics.366installs17Conan VcpkgThe conan-vcpkg skill from mohitmishra786/low-level-dev-skills teaches agents to manage C and C++ dependencies with Conan or vcpkg, covering manifests, toolchains, and CI-friendly integration so native CLI, API, and game backends build reliably across environments.365installs18Msvc Clmsvc-cl is a low-level Windows build skill for developers who need MSVC cl.exe and link.exe instead of GCC or Clang. The skill covers SDK version management, PDB debug symbol generation, and MSVC-specific compiler and linker flags for Visual Studio projects and headless CI pipelines on Windows runners. Developers reach for msvc-cl when porting native code, debugging release builds, or configuring automated Windows compilation where incorrect flags or missing PDBs break production diagnostics. The skill targets engineers shipping Windows desktop services, game middleware, or native extensions who must reason about MSVC toolchains without hand-waving generic C++ advice.361installs19LldbTeaches LLDB workflows for diagnosing native crashes and concurrency bugs: launching targets, reading stacks and registers, scripting repeatable debug sessions, and validating fixes on CLI, mobile, and server binaries.360installs20FuzzingGuides coverage-guided fuzzing for low-level code: writing harnesses, seeding corpora, integrating libFuzzer or AFL, triaging crashes, and gating releases for APIs, CLIs, and agents handling untrusted binary input.357installs21Cpu Cache Optcpu-cache-opt is a low-level performance skill from mohitmishra786/low-level-dev-skills for developers optimizing CPU-bound code paths. The skill walks through restructuring hot loops, choosing cache-friendly data layouts, and reshaping memory access patterns so fewer lines miss L1/L2/L3 caches during parser scans, API serialization, and engine inner loops. It targets measurable latency wins in backends where profiling shows memory stalls rather than algorithmic complexity as the bottleneck. Developers reach for cpu-cache-opt when flamegraphs or perf counters show cache-miss pressure on tight loops, struct-of-arrays versus array-of-structs tradeoffs matter, or prefetch and alignment decisions need a structured review before shipping a performance-critical module.356installs22FlamegraphsWalks through capturing stack samples and rendering flame graphs for C/C++ and systems workloads. Shows how to fold traces, read plateaus, and prioritize optimizations in APIs, CLIs, and multi-tenant SaaS backends.353installs23Memory ModelCovers CPU memory models and atomic ordering for low-level development so agents pick correct synchronization, explain visibility guarantees, and avoid subtle races in concurrent CLI tools and native API backends.352installs24ValgrindCovers running Valgrind memcheck (and related tools) on native builds to detect leaks, use-after-free, buffer overruns, and race-prone threading. Emphasizes reproducible commands, suppression hygiene, and turning Valgrind output into concrete fixes before shipping.351installs25NinjaExplains how to structure Ninja build files and integrate them with CMake or Meson so agents produce fast, reliable incremental native builds for CLI utilities and API services in local dev and CI.350installs26Elf InspectionExplains how to read and interpret ELF executables and shared objects: segments, sections, dynamic linking metadata, and symbol visibility. Enables engineers to triage loader errors and audit native dependencies in CLI and server releases.348installs27Linkers LtoGuides configuring link-time optimization across common native toolchains so agents can choose correct LTO modes, linker flags, and release settings for smaller, faster CLI and API binaries without guesswork.347installs28Dynamic LinkingCovers designing and debugging dynamic linking on Unix: building .so files, runtime loading, symbol resolution, and loader paths. Helps teams add plugin architectures to CLIs, native APIs, and browser-style extension hosts.340installs29EbpfExplains building eBPF programs for Linux: writing kernel bytecode, managing maps, attaching kprobes/tracepoints, loading with libbpf, and integrating observability or policy hooks into APIs, CLIs, and agent tooling.340installs30Rust FfiDocuments safe and unsafe Rust FFI patterns: ABI-stable structs, bindgen-generated bindings, link directives in build.rs, CString lifetimes, and panic boundaries. Helps agents integrate Rust with C/C++ SDKs, wrap system libraries, and avoid undefined behavior from mismatched calling conventions or double-free across the boundary.336installs31Rust ProfilingTeaches Rust performance investigation using sampling profilers, flamegraphs, tracing instrumentation, and micro-benchmarks. Helps agents interpret hot paths in async and sync code, compare release builds with debug info, and recommend targeted fixes for lock contention, excessive cloning, and allocator pressure before shipping.335installs32Strace LtraceTeaches strace and ltrace workflows for Linux incident response so agents capture syscall and library-call traces, interpret common failure patterns, and narrow root causes in CLI daemons and API services under load.335installs33BinutilsExplains GNU binutils for low-level troubleshooting: disassembling objects, tracing undefined symbols, inspecting ELF sections and relocations, interpreting linker maps, and fixing release-only faults revealed by binary analysis tools.334installs34MesonTeaches Meson project layout, dependency declarations, generator expressions, cross-compilation files, subproject wraps, and Ninja invocation. Useful when replacing hand-rolled Makefiles with portable builds for C, C++, and Rust-adjacent native code in CI and embedded firmware workflows.331installs35Cargo WorkflowsDocuments idiomatic Cargo workflows for Rust projects: workspace structuring, feature and target configuration, bench/test pipelines, cross-compilation, publishing crates, and keeping local developer commands aligned with CI build steps.329installs36InterpretersGuides implementing interpreters from scratch: tokenizing source, building ASTs or bytecode, dispatch loops, and embedding native builtins. Suited for CLIs, agent sandboxes, and APIs exposing safe user-defined logic without shipping a full compiler.326installs37Rust UnsafeProvides patterns for writing, encapsulating, and testing unsafe Rust in backend and FFI layers, emphasizing documented invariants, layout correctness, and safe public wrappers around performance-critical internals.326installs38Heaptrackheaptrack skill covers Linux heap profiling for C/C++ binaries: recording allocation stacks, visualizing peak usage, comparing builds for regressions, and tying memory churn to source paths during ship-stage performance hardening of CLI, API, and game services.325installs39Rust DebuggingGuides low-level Rust debugging across native debuggers, structured logging, and backtrace configuration to isolate panics, ownership violations, and concurrency bugs in CLI and systems binaries.324installs40Zig DebuggingZig-debugging skill teaches Claude low-level diagnosis for Zig programs: interpreting panics, using debuggers, isolating allocator bugs, and shrinking failing tests. It targets CLI tools, native services, and performance-sensitive codebases where ship-quality means proving fixes under real binaries, not just passing superficial compile checks.322installs41Wasm EmscriptenDocuments compiling C/C++ to WebAssembly with Emscripten, including emcc configuration, JavaScript interop, runtime embedding, and shipping optimized .wasm plus glue code for browser-based SaaS, extensions, and games.318installs42PgoDocuments end-to-end profile-guided optimization for native toolchains so agents design profiling runs, apply compiler PGO flags correctly, and validate measurable speedups on CLI and API release binaries.317installs43Debug Optimized BuildsTeaches how to debug compiler-optimized release builds where inlining, reordering, and stripped symbols obscure source-level debugging. Emphasizes DWARF preservation, disassembly, strategic instrumentation, and gdb/lldb tactics without fully disabling optimizations.316installs44Cpp ModulesTeaches C++20 modules for modular native builds: defining exportable interfaces, migrating from headers, configuring CMake or similar, and avoiding linkage surprises. Targets teams shipping CLI utilities and high-performance APIs.315installs45Openocd Jtagopenocd-jtag skill documents OpenOCD JTAG/SWD debugging for embedded backends: board configs, flashing firmware, connecting GDB remotely, inspecting fault registers, and stabilizing on-device bring-up for CLI firmware tools and hardware-integrated API prototypes.315installs46Cpp CoroutinesGuides designing and implementing modern C++ coroutines for async backends: promise types, awaitables, symmetric transfer, and lifetime rules. Covers when coroutines beat threads or callbacks in CLI tools, APIs, and game engines.312installs47Zig Build SystemGuides agents through Zig's build system: structuring build.zig, defining build steps, linking C/Zig modules, caching artifacts, and running zig build for systems and CLI targets in mohitmishra786/low-level-dev-skills.312installs48Hardware CountersTeaches reading and configuring hardware performance counters on Linux for low-level tuning: selecting PMU events, interpreting cache and branch metrics, and correlating results with code changes in APIs, CLIs, and game loops.311installs49Zig CrossTeaches Zig cross-compilation from low-level-dev-skills: selecting targets, managing sysroots and linkers, building for Linux/macOS/Windows/arm from one host, and validating shipped native binaries across platforms.310installs50Rust Sanitizers MiriTeaches running Miri and LLVM sanitizers on Rust crates to detect undefined behavior, invalid references, and data races in unsafe, FFI, and performance-critical code paths prior to shipping.308installs51Rust CrossGuides Rust cross-compilation setup for shipping binaries to multiple OS and CPU targets, covering target triples, linker config, libc choices, and CI patterns for CLI, API, and mobile-adjacent native artifacts.307installs52Rustc BasicsIntroduces the Rust compiler and Cargo workflow: crate types, target triples, feature flags, profiles, workspaces, and common error remediation. Gives agents a foundation for low-level Rust work so later skills like no_std, FFI, and profiling build on correct compile commands and artifact expectations.306installs53Rust SecurityCovers Rust-specific application security: auditing dependencies, reviewing unsafe and FFI surfaces, managing secrets, and applying secure defaults for CLI tools, APIs, and backend services before launch.304installs54Cpp TemplatesCovers C++ template metaprogramming for low-level development: generic APIs, type traits, constexpr utilities, and compile-time patterns used in performant backend services, CLIs, and game engine subsystems.302installs55Wasm WasmtimeCovers building and embedding WebAssembly with Wasmtime so agents compile modules, configure WASI capabilities, expose safe host imports, and integrate sandboxed Wasm backends into CLIs, agents, and API edge runtimes.300installs56Zig CinteropExplains Zig-to-C interoperability: importing headers, modeling C types with comptime checks, configuring build.zig link flags, and wrapping foreign calls with Zig error handling for native CLI and API tooling.297installs57Linker ScriptsGuides creation and troubleshooting of GNU ld and LLD linker scripts for low-level Rust, C, and C++ projects. Covers section ordering, vector tables, heap and stack sizing, PROVIDE symbols, and reading map files to fix overlap, missing symbols, and boot failures on embedded and custom-kernel targets.288installs58Concurrency DebuggingGuides systematic debugging of concurrent low-level code: reproducing intermittent failures, interpreting sanitizer output, tracing lock order, and isolating shared-state races in threaded APIs, CLIs, and agents.285installs59Embedded RustCovers Rust embedded development for microcontrollers and bare-metal targets: no_std project layout, HAL and board support crates, cross-target builds, flash/debug probes, peripheral configuration, and safe patterns under tight RAM and flash constraints.285installs60Assembly RiscvTeaches RISC-V assembly patterns including instruction selection, ABI compliance, and linkage conventions for writing and reviewing hand-tuned low-level systems code.280installs61Build AccelerationDocuments techniques to reduce compile and link latency for low-level projects via caching, parallelism, incremental toolchains, and CI configuration tuned for native codebases.278installs62ZephyrGuides Zephyr RTOS project setup, devicetree configuration, Kconfig tuning, and driver integration for resource-constrained embedded devices requiring deterministic scheduling and hardware abstraction.268installs63Zig CompilerCovers practical Zig compiler usage from low-level-dev-skills: choosing build modes, interpreting diagnostics, applying comptime features, and producing correct native binaries for systems and performance-sensitive backends.266installs64Rust No StdCovers Rust no_std firmware: disabling std, supplying panic and alloc handlers, using embedded-hal traits, configuring target JSON specs, and linking with custom memory layouts. Enables agents to scaffold microcontroller crates, choose nightly features judiciously, and avoid std-only APIs in IRQ-critical paths.265installs65Binary HardeningDocuments binary hardening for native builds: selecting compiler and linker mitigations, enabling stack canaries and full RELRO, enforcing PIE and NX, auditing ELF/PE security properties, and validating protections before shipping executables.260installs66Include What You Useinclude-what-you-use skill teaches IWYU workflows for C/C++ backends: analyzing include graphs, applying fix hints, enforcing direct includes in CI, and shrinking compile/link cost for CLI tools, native APIs, and performance-sensitive game engine modules.259installs67Rust Async InternalsDeep Rust async internals skill covering futures, wakers, executors, pinning, and runtime scheduling for backend services. Helps engineers reason about poll loops, cancellation, and concurrency pitfalls when building APIs, CLIs, and agent backends that must remain correct and fast under load.259installs68Rust Build TimesTeaches practical Rust build-time optimization: dev vs release profiles, feature unification, workspace structure, faster linkers, distributed caching, and measuring compile regressions in local and CI environments.258installs69Intel Vtune Amd UprofTeaches low-level performance profiling with Intel VTune and AMD uProf for backend and systems code. Explains sampling methodology, reading flame graphs, interpreting PMU counters, and turning findings into concrete ship-ready optimizations for CLI, API, and SaaS workloads.256installs70Zig ComptimeTeaches Zig compile-time execution for generics, schema validation, and code generation in backend modules, enabling zero-cost abstractions and type-checked protocols without external macro systems or runtime reflection.256installs71Dwarf Debug FormatSkill for reading and interpreting DWARF debug metadata in ELF and Mach-O binaries so developers can map machine addresses to source lines, functions, and variables during native crash triage.252installs72Ebpf RustCovers Rust-based eBPF development: project structure with aya or redbpf, generating verifier-safe programs, typed map I/O, and embedding loaders into backend agents, CLIs, and observability APIs on Linux.250installs73Zig TestingCovers Zig native testing primitives including test declarations, comptime tests, and project-level execution patterns for validating systems code without external test frameworks.249installs74BazelGuides Bazel setup for low-level and polyglot projects: WORKSPACE/BUILD.bazel targets, dependency pinning, sandboxed actions, remote execution/cache, and CI integration for faster reproducible builds.243installs