c-optimizer
/c-optimizer
Audit and optimize C23 codebases (GCC 16/Clang 22/MSVC, CMake, Make, pkg-config) for build flags, undefined behavior and memory ownership, buffer/format-string safety, allocation and cache behavior, pthread/atomics concurrency, syscall and I/O cost, sanitizers/fuzzing, and profiling, with real before/after measurement. Always produces a written findings report and a fix plan for approval before touching code. Use this whenever the user mentions slow C, memory leaks/segfaults, valgrind/ASan/UBSan, `-O2`/LTO/PGO, CMake flags, pthread data races, buffer overflows, or "optimize my C code" -- even
- Author
- RuneStone-Tech ↗
- Repository
- optimize-anything ↗
- Licence
- MIT
- Last repository change
- 04.11.2026
Assessment and security
- Files in this package
- 10
- Scripts
- 1
- HTML comments
- 0
- URLs in SKILL.md
- 1
No signals detected. Repository changed on 04.11.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
- 1 scripts in this package. Review them before installing, as Claude may execute them.
Scripts: scripts/audit.py
What it does and when to use it
Audit and optimize C23 codebases (GCC 16/Clang 22/MSVC, CMake, Make, pkg-config) for build flags, undefined behavior and memory ownership, buffer/format-string safety, allocation and cache behavior, pthread/atomics concurrency, syscall and I/O cost, sanitizers/fuzzing, and profiling, with real before/after measurement. Always produces a written findings report and a fix plan for approval before touching code. Use this whenever the user mentions slow C, memory leaks/segfaults, valgrind/ASan/UBSan, `-O2`/LTO/PGO, CMake flags, pthread data races, buffer overflows, or "optimize my C code" -- even
Triggers from the description
Original author description
Audit and optimize C23 codebases (GCC 16/Clang 22/MSVC, CMake, Make, pkg-config) for build flags, undefined behavior and memory ownership, buffer/format-string safety, allocation and cache behavior, pthread/atomics concurrency, syscall and I/O cost, sanitizers/fuzzing, and profiling, with real before/after measurement. Always produces a written findings report and a fix plan for approval before touching code. Use this whenever the user mentions slow C, memory leaks/segfaults, valgrind/ASan/UBSan, `-O2`/LTO/PGO, CMake flags, pthread data races, buffer overflows, or "optimize my C code" -- even
How it works
- Workflow
- Principles
- Docs
SKILL.md preview
--- name: c-optimizer description: Audit and optimize C23 codebases (GCC 16/Clang 22/MSVC, CMake, Make, pkg-config) for build flags, undefined behavior and memory ownership, buffer/format-string safety, allocation and cache behavior, pthread/atomics concurrency, syscall and I/O cost, sanitizers/fuzzing, and profiling, with real before/after measurement. Always produces a written findings report and a fix plan for approval before touching code. Use this whenever the user mentions slow C, memory leaks/segfaults, valgrind/ASan/UBSan, `-O2`/LTO/PGO, CMake flags, pthread data races, buffer overflows, or "optimize my C code" -- even if they never say audit or optimize. --- # C Optimizer C is fast until the build is wrong, memory ownership is unclear, or the hot loop fights the cache. C23 is the current language revision (GCC 15+ defaults to it); optimization is mostly build flags, data layout, allocation strategy, I/O and correctness under UB. Nothing is edited before approval because ownership and concurrency changes can break callers. ## Workflow ### 1. Scope (quick) - Find the project root and record the toolchain: C standard/compiler, CMake/Make/Meson, build type and flags, libc/platform, sanitizer/fuzzing setup, threading model, and target architecture. - Run `python <skill-dir>/scripts/audit.py <project-root>` -- static scan of build files and sources for legacy standards, debug flags in release, unchecked buffers, allocation/copy cost, data races, blocking I/O, missing sanitizers, with file:line evidence. Use `--json` to post-process. - Classify the pain: throughput/latency, memory growth, CPU saturation, concurrency/correctness, I/O or database cost, build/startup, or safety/maintenance. Ask which hurts if unclear. - Read `references/tooling.md` once: what can be measured here. ### 2. Audit The script finds cheap leads; you find the rest by reading the hot path and the build. Read the build manifest, entrypoint, the 3-5 hot functions/endpoints and the data layer. Load only what applies: | Build, toolchain and runtime | `references/build-runtime.md` | | Memory, layout and concurrency | `references/memory-concurrency.md` | | I/O, syscalls and data | `references/io-data.md` | | Safety and quality | `references/safety-quality.md` | | Measurement | `references/tooling.md` | **Measure, never guess.** Build with production settings, run with production data/load, and profile that. Debug builds, dev servers and a single request are not evidence. Take a profile before micro-optimizing and a heap/allocator snapshot before raising limits. Mark each finding **Confirmed** (profile/load/code evidence) or **Suspected** (needs measuring). ### 3. Report Fill `assets/report-template.md`, save it as `C_OPTIMIZATION_REPORT.md` in the project root, and show the user. Five-line summary, findings table by impact/effort, then per-finding detail (evidence, why it hurts, fix, risk, behavior impact). Group near-duplicates. ### 4. Plan -- then stop for approval Use plan mode: `EnterPlanMode` (load with ToolSearch if deferred), write the plan, present with `ExitPlanMode`; if unavailable show it in chat and wait for an explicit "go". Structure: 1. **Quick wins** -- build flags, missing indexes/caching, timeouts/pool limits, avoidable allocations/copies, sync I/O in hot paths, missing `await`/join, safer bounds checks, log noise, config limits. Low risk. 2. **Structural** -- bound concurrency, batch N+1, stream large payloads, change data structures/ownership, split hot paths, cache correctly, connection/worker pools, graceful shutdown, observability. Name each behavior change. 3. **Heavy** -- language/toolchain major upgrade, runtime/GC change, framework/ORM swap, architecture change, AOT/trimming, database migration. Separately approved. Each step: files touched, expected effect, how to verify, how to roll back. ### 5. Fix Only approved items, in small groups. After each: build with production flags, run the test suite, and re-run the same benchmark/profile. A break must trace to one change. Do not mix a toolchain major upgrade with optimization edits. If a change alters ownership, concurrency, API/DB semantics or failure behavior, stop and ask. ### 6. Verify and wrap up Re-measure the same workload and data: throughput and p50/p95/p99, CPU, RSS/heap, allocations/GC, I/O, error rate, build time and binary/image size. State plainly what could not be measured. End with deferred items and one suggested next step. ## Principles - **Correctness is performance.** UB, races and overflows invalidate every benchmark. - **Measure release builds.** `-O0` and debug assertions are not production. - **Ownership is the contract.** Every allocation has one owner and one free path. - **Data layout beats micro-tuning.** Cache locality and fewer allocations usually win. - **Sanitizers before optimizations.** ASan/UBSan/TSan find the bugs that make numbers meaningless. ## Docs - https://en.cppreference.com/c/23
Files in this package (10)
- LICENSE 1 KB
- README.md 1 KB
- SKILL.md 5 KB
- assets/report-template.md 1 KB
- references/build-runtime.md 1 KB
- references/io-data.md 1 KB
- references/memory-concurrency.md 1 KB
- references/safety-quality.md 1 KB
- references/tooling.md 1 KB
- scripts/audit.py 9 KB
Versions
The database has no other skills named c-optimizer.
Database snapshot: 13.11.2026 · package version cebee7125824 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 85cpp-optimizer
Audit and optimize C++23 codebases (GCC 16, Clang 22, MSVC 14.52, CMake) for build flags/LTO/PGO, RAII and smart-pointer ownership, copies/moves and allocations, cache locality and data layout, threading/atomics/coroutines, I/O and formatting, UB/sanitizers/hardening, and… - 100sota-c-cpp
State-of-the-art C and C++ engineering rules that Claude applies when writing or auditing C/C++. Covers modern idioms (RAII, value semantics, smart pointers, C++23), memory safety (lifetimes, bounds, sanitizers, hardening flags), undefined behavior, security (SEI CERT C/C++,… - 85go-optimizer
Audit and optimize Go projects (services on net/http, gin, echo, chi, gRPC; CLIs; libraries; modules and workspaces) for runtime speed, allocations and GC pressure, goroutine and concurrency bugs, database latency, binary size, build time and safety, with real before/after… - 100cpp
Use when writing, reviewing, modernizing, building, or debugging C++ - RAII and resource lifetime, smart-pointer ownership, move semantics and the Rule of Zero/Five, target-based CMake with FetchContent, and killing undefined behavior with ASan/UBSan/TSan plus clang-tidy. NOT… - 90gcc
Use when a C or C++ build uses GCC and needs build-mode flags, warning triage, debug info, LTO, PGO, or a compilation error explained. Not for Clang-only diagnostics: use clang. - 100c-systems
C patterns for systems code, libraries, and native extensions: module layout, function decomposition, status-enum errors, memory safety, undefined behavior, and performance measurement. Use when writing, reviewing, refactoring, or debugging C, working with malloc lifetimes,…