Skip to content
Skills Library
Programming · Review & audit

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

Licence
MIT
Last repository change
04.11.2026

Assessment and security

85/ 100Class: good
Format20 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content25 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
10
Scripts
1
HTML comments
0
URLs in SKILL.md
1
Deprecation

No signals detected. Repository changed on 04.11.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What to check before installing
  • 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

optimize my C code
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

  1. Workflow
  2. Principles
  3. Docs
Original SKILL.md headings · 61 lines, 598 words
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,…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.