skills.rest
kaynetik
kaynetikCOMMUNITY
Explore all skills by this author →
Website𝕏@kaynetikGitHub

c-cpp-compilers

Provide GCC and Clang compiler flag, sanitizer, and CMake guidance for C and C++ projects.

1|Updated Mar 20, 2026
Search Tags:#clang#compilation#static-analysis#sanitizers#gcc#lto#pgo
One-click install
npx skills add https://github.com/kaynetik/skills --skill c-cpp-compilers
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: c-cpp-compilers
Source: https://github.com/kaynetik/skills/tree/main/c-cpp-compilers
Command: npx skills add https://github.com/kaynetik/skills --skill c-cpp-compilers

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Modern C and C++ projects require careful selection of compiler flags, build modes, sanitizer and static analysis configurations, and link-time optimizations to be correct, fast, and debuggable. Many developers struggle to interpret cryptic diagnostics, choose between GCC and Clang behaviors, reproduce sanitizer reports, or configure PGO and LTO correctly for CI and release builds. This Skill centralizes practical guidance, triage steps, and repeatable CMake and toolchain recommendations to reduce time spent debugging builds and runtime UB.

Core Features & Use Cases

  • Practical guidance on compiler selection and flag tradeoffs including optimization levels, size vs speed decisions, and hardening flags.
  • Sanitizer and runtime triage: recommended sanitizer combinations, runtime options, interpretation of ASan/UBSan/TSan reports, and CMake integration for testing.
  • Static analysis and linting workflows: how to generate a compilation database, run clang-tidy, cppcheck, scan-build, and GCC's analyzer with CI examples and suppression patterns.
  • Build optimization workflows: step-by-step LTO and PGO recipes for GCC and Clang, and advice on ThinLTO, linkers, and archive handling.
  • CMake and modules guidance: snippets and patterns for sanitizer toggles, export of compile commands, and building C++20/23 modules with modern CMake.
  • Use case example: triage an AddressSanitizer report from CI, produce a minimal reproducer, recommend build flags to reproduce locally, and propose a CI sanitizer job configuration.

Quick Start

Analyze my project's build and provide concrete GCC or Clang flag recommendations, sanitizer and static analysis settings, and CMake snippets to reproduce and fix any reported issues.

Frequently Asked Questions about c-cpp-compilers

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I choose the best GCC or Clang optimization flags for my C++ project?▼

Selecting GCC or Clang optimization flags requires balancing size versus speed and applying hardening flags. This Skill provides actionable toolchain guidance and concrete flag recommendations to configure correct, fast, and debuggable builds.

How do I configure AddressSanitizer and UBSan in CMake for CI?▼

Configuring sanitizers in CMake for CI involves using specific toggles and runtime options. This Skill delivers CMake snippets, recommended sanitizer combinations, and CI integration instructions to reproduce and triage ASan, UBSan, and TSan reports.

What is the best way to set up clang-tidy and static analysis workflows?▼

Setting up static analysis workflows requires generating a compilation database and running linters. This Skill guides you through exporting compile commands, running clang-tidy, cppcheck, and scan-build, plus providing CI examples and suppression patterns.

How do I configure LTO and PGO for release builds in C++?▼

Configuring LTO and PGO for release builds requires step-by-step recipes for GCC and Clang toolchains. This Skill provides build optimization workflows covering ThinLTO, linker configurations, and archive handling to maximize runtime performance.

Why does my C++20 modules build fail with modern CMake?▼

C++20 modules builds often fail due to incorrect CMake configurations or toolchain incompatibilities. This Skill offers CMake and modules guidance, including snippets and patterns for sanitizer toggles and building modern C++ projects correctly.

Does this Skill provide guidance on interpreting cryptic linker or diagnostic errors?▼

Interpreting cryptic linker or diagnostic errors is a core feature of this Skill. It delivers diagnostic interpretation steps, triage procedures, and repeatable toolchain recommendations to reduce time spent debugging builds and runtime undefined behavior.

Related Skills

Explore More Software Engineering Skills→
zhinkgitzhinkgit
551

gcc

Build CMake-based arm-none-eabi GCC projects and report ELF sizes in JSON.

Community
Advanced
RedtropigRedtropig
14

cpp-sanitizers

Instrument C/C++ builds with ASan, UBSan, and TSan to detect runtime bugs.

Community
Advanced
martimramosmartimramos
1

forge-lang-c

Standardize C project builds with Makefile, CMake, and gcc/clang toolchains.

Community
Basic
Devvraj10Devvraj10

diagnostics

Retrieve LSP diagnostics for syntax and type errors and suggest project rollbacks.

Community
Intermediate