Modern Cpp — Agent Skill by Trail of Bits

From the author

Guides C++ code toward modern idioms (C++20/23/26). Use when writing new C++ code, modernizing legacy patterns, or working on security-critical C++. Replaces raw pointers with smart pointers, SFINAE with concepts, printf with std::print, error codes with std::expected.

— the description by Trail of Bits

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides a comprehensive framework for transitioning C++ codebases toward modern standards. It emphasizes patterns that eliminate common vulnerability classes, such as memory leaks and buffer overflows, by replacing legacy C-style constructs with modern, type-safe alternatives. The content includes migration tables for anti-patterns, compiler hardening configurations, and feature tiers based on practical usability.

What it does

Provides migration paths from legacy C++ patterns to modern C++20/23/26 idioms.
Lists specific anti-patterns and their safer, modern replacements.
Details compiler hardening flags for GCC and Clang to improve security.
Explains the use of hardened libc++ modes for bounds-checking.
Categorizes C++ features by their current practical deployment readiness.
Offers a checklist for adopting safe coding practices in new and existing projects.

When to use it

When writing new C++ functions, classes, or libraries.
When modernizing legacy C++ codebases to improve safety and maintainability.
When working on security-critical or safety-sensitive C++ applications.
When reviewing C++ code to ensure adoption of modern idioms.
When configuring compiler and linker settings for enhanced security.

Advantages

Reduces vulnerability classes like memory leaks and buffer overflows.
Improves code readability and reduces boilerplate through modern language features.
Provides actionable, security-focused compiler and linker configurations.
Offers clear, evidence-based guidance on replacing legacy C-style constructs.
Helps align code with current C++ standards for better long-term maintainability.

Usage examples

“How should I replace raw pointers in my C++ code?”: The skill recommends using std::unique_ptr for exclusive ownership or std::shared_ptr for shared ownership to ensure RAII semantics and eliminate manual memory management.
“What are the recommended compiler flags for hardening a C++ project?”: The skill provides a list of essential flags including -D_FORTIFY_SOURCE=3, -fstack-protector-strong, and -ftrivial-auto-var-init=zero, along with linker settings like -Wl,-z,relro,-z,now.
“How can I replace printf in C++23?”: The skill suggests using std::print or std::println, which are type-safe and avoid the format string vulnerabilities associated with printf.
“What is the modern alternative to SFINAE?”: The skill advises using C++20 Concepts and the requires clause to constrain templates, which provides more readable code and clearer error messages.

Install

Download the skill as a ZIP:
https://autogineer.com/agent-skills/trailofbits/modern-cpp/download

Unzip it into the cross-client skills folder of your project:

mkdir -p .agents/skills && unzip modern-cpp.zip -d .agents/skills

Documentation by Trail of Bits

Modern C++

Guide for writing modern C++ using C++20, C++23, and C++26 idioms. Focuses on patterns that eliminate vulnerability classes and reduce boilerplate, with a security emphasis from Trail of Bits.

When to Use This Skill

Writing new C++ functions, classes, or libraries
Modernizing existing C++ code (pre-C++20 patterns)
Choosing between legacy and modern approaches
Working on security-critical or safety-sensitive C++
Reviewing C++ code for modern idiom adoption

When NOT to Use This Skill

User explicitly requires older standard: Respect constraints (embedded, legacy ABI)
Pure C code: This skill is C++-specific
Build system questions: CMake, Meson, Bazel configuration is out of scope
Non-C++ projects: Mixed codebases where C++ isn't primary

Anti-Patterns to Avoid

Avoid	Use Instead	Why
`new`/`delete`	`std::make_unique`, `std::make_shared`	Eliminates leaks, double-free
Raw owning pointers	`std::unique_ptr`, `std::shared_ptr`	RAII ownership semantics
C arrays (`int arr[N]`)	`std::array<int, N>`	Bounds-aware, value semantics
Pointer + length params	`std::span<T>`	Non-owning, bounds-checkable
`printf` / `sprintf`	`std::format`, `std::print`	Type-safe, no buffer overflow
C-style casts `(int)x`	`static_cast<int>(x)`	Explicit intent, auditable
`#define` constants	`constexpr` variables	Scoped, typed, debuggable
SFINAE / `enable_if`	Concepts + `requires`	Readable constraints and errors
Error codes + out params	`std::expected<T, E>`	Composable, type-safe errors
`union`	`std::variant`	Type-safe, no silent UB
Raw `mutex.lock()/unlock()`	`std::scoped_lock`	Exception-safe, no deadlocks
`std::thread`	`std::jthread`	Auto-join, stop token support
`assert()` macro	`contract_assert` (C++26)	Visible to tooling, configurable
Manual CRTP	Deducing `this` (C++23)	Simpler, no template boilerplate
Macro code generation	Reflection (C++26)	Zero-overhead, composable

See anti-patterns.md for the full table (30+ patterns).

Decision Tree

What are you doing?
|
+-- Writing new C++ code?
|   +-- Use modern idioms by default (C++20/23)
|   +-- Choose the newest standard your compiler supports
|   +-- See Feature Tiers below
|
+-- Modernizing existing code?
|   +-- Start with Tier 1 (C++20/23) replacements
|   +-- Prioritize by security impact (memory > types > style)
|   +-- See anti-patterns.md for the migration table
|
+-- Security-critical code?
|   +-- Enable compiler hardening flags (see below)
|   +-- Enable hardened libc++ mode
|   +-- Run sanitizers in CI
|   +-- See safe-idioms.md and compiler-hardening.md
|
+-- Using C++26 features?
    +-- Reflection: YES, plan for it (GCC 16+)
    +-- Contracts: cautiously, for new API boundaries
    +-- std::execution: wait for ecosystem maturity
    +-- See cpp26-features.md

Feature Tiers

Features are ranked by practical usability today, not by standard version.

Tier 1: Use Today (C++20/23, solid compiler support)

Feature	Replaces	Standard
Concepts + `requires`	SFINAE, `enable_if`	C++20
Ranges + views	Raw iterator loops	C++20
`std::span<T>`	Pointer + length	C++20
`std::format`	`sprintf`, iostream chains	C++20
Three-way comparison `<=>`	Manual comparison operators	C++20
`std::jthread`	`std::thread` + manual join	C++20
Designated initializers	Positional struct init	C++20
`std::expected<T,E>`	Error codes, exceptions at boundaries	C++23
`std::print` / `std::println`	`printf`, `std::cout <<`	C++23
Deducing `this`	CRTP, const/non-const duplication	C++23
`std::flat_map`	`std::map` for read-heavy use	C++23
Monadic `std::optional`	Nested if-checks on optionals	C++23

See cpp20-features.md and cpp23-features.md.

Tier 2: Deploy Now (no standard bump needed)

These improve safety without changing your C++ standard version:

Compiler hardening flags — -D_FORTIFY_SOURCE=3, -fstack-protector-strong, -ftrivial-auto-var-init=zero
Hardened libc++ — -D_LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_FAST for ~0.3% overhead bounds-checking
Sanitizers in CI — ASan + UBSan as minimum; TSan for concurrent code
Warning flags — -Wall -Wextra -Wpedantic -Werror

See compiler-hardening.md.

Tier 3: Plan For (C++26, worth restructuring around)

Reflection is the single most transformative C++26 feature. It eliminates:

Serialization boilerplate (one generic function replaces per-struct to_json)
Code generators (protobuf codegen, Qt MOC)
Macro-based registration and enum-to-string hacks

GCC 16 (April 2026) has reflection merged. Plan new code to benefit from it.

Tier 4: Watch (C++26, needs maturation)

Contracts (pre/post/contract_assert) — Better than assert(), but no virtual function support and limited compiler support. Adopt cautiously for new API boundaries.
std::execution (senders/receivers) — Powerful async framework, but steep learning curve, no scheduler ships with it, and poor documentation. Wait for ecosystem maturity.

See cpp26-features.md.

Compiler Hardening Quick Reference

Essential Flags (GCC + Clang)

-Wall -Wextra -Wpedantic -Werror
-D_FORTIFY_SOURCE=3
-fstack-protector-strong
-fstack-clash-protection
-ftrivial-auto-var-init=zero
-fPIE -pie
-Wl,-z,relro,-z,now

Clang-Specific

-Wunsafe-buffer-usage

Hardened libc++ (Clang/libc++ only)

-D_LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_FAST

Google deployed this across Chrome and their server fleet: ~0.3% overhead, 1000+ bugs found, 30% reduction in production segfaults.

See compiler-hardening.md for the full guide.

Rationalizations to Reject

Rationalization	Why It's Wrong
"It compiles without warnings"	Warnings depend on which flags you enable. Add `-Wall -Wextra -Wpedantic`.
"ASan is too slow for production"	Use GWP-ASan for sampling-based production detection (~0% overhead).
"We only use safe containers"	Iterator invalidation and unchecked `optional` access are still exploitable.
"Smart pointers are slower"	`std::unique_ptr` has zero overhead vs raw pointers. Measure before claiming.
"Our code doesn't have memory bugs"	Google found 1000+ bugs when enabling hardened libc++. So did everyone else.
"C++26 features aren't available yet"	C++20/23 features are. Hardening flags work on any standard. Start there.
"Modern C++ is harder to read"	`std::expected` is more readable than checking error codes across 5 out-params.

Best Practices Checklist

[ ] Use smart pointers for ownership, raw pointers only for non-owning observation
[ ] Prefer std::span over pointer + length for function parameters
[ ] Use std::expected for functions that can fail with typed errors
[ ] Constrain templates with concepts, not SFINAE
[ ] Enable compiler hardening flags and hardened libc++ in all builds
[ ] Run ASan + UBSan in CI; add TSan for concurrent code
[ ] Use constexpr / consteval where possible (UB-free by design)
[ ] Mark functions [[nodiscard]] when ignoring the return value is likely a bug
[ ] Prefer value semantics; use std::variant over union, enum class over enum
[ ] Initialize all variables at declaration

Files

ATTRIBUTION.mdAdded by AutoGineer924 B
LICENSELicence file added by AutoGineer19.7 KiB
SKILL.md8.5 KiB
references/anti-patterns.md5.5 KiB
references/compiler-hardening.md7.3 KiB
references/cpp20-features.md7.0 KiB
references/cpp23-features.md7.0 KiB
references/cpp26-features.md7.5 KiB
references/safe-idioms.md8.1 KiB

references/compiler-hardening.md

Compiler Hardening

Security-focused compiler and linker configuration for C++ projects. Based on the OpenSSF Compiler Options Hardening Guide and Trail of Bits recommendations.

Essential Compiler Flags

Warnings

Flag	Purpose	GCC	Clang
`-Wall`	Core warnings	Yes	Yes
`-Wextra`	Additional warnings	Yes	Yes
`-Wpedantic`	Strict ISO compliance	Yes	Yes
`-Werror`	Treat warnings as errors	Yes	Yes
`-Wconversion`	Implicit narrowing conversions	Yes	Yes
`-Wsign-conversion`	Signed/unsigned conversion	Yes	Yes
`-Wformat=2`	Format string issues	Yes	Yes
`-Wunsafe-buffer-usage`	Raw pointer arithmetic	No	Yes

Stack Protection

Flag	Purpose	GCC	Clang
`-fstack-protector-strong`	Stack buffer overflow detection	Yes	Yes
`-fstack-clash-protection`	Prevent stack clash attacks	Yes	Yes

Fortification

-D_FORTIFY_SOURCE=3

Adds runtime bounds checks to memcpy, strcpy, sprintf, and other libc functions. Level 3 (GCC 12+, Clang 16+) provides the most coverage.

Warning: This flag is silently ignored if optimization is disabled (-O0). Always verify it's active:

# Check that _FORTIFY_SOURCE is defined in preprocessor output
echo '#include <stdio.h>' | gcc -E -dM -D_FORTIFY_SOURCE=3 -O2 - | grep FORTIFY

Trail of Bits found 20+ projects on GitHub where _FORTIFY_SOURCE was misspelled (e.g., -FORTIFY_SOURCE=2 instead of -D_FORTIFY_SOURCE=2).

Auto-Initialization

-ftrivial-auto-var-init=zero

Zero-initializes all local variables that would otherwise be uninitialized. Eliminates information leaks from stack variables at minimal performance cost.

Position-Independent Code

-fPIE -pie              # for executables
-fPIC -shared           # for shared libraries

Required for ASLR to work effectively.

Linker Hardening

Flag	Purpose
`-Wl,-z,relro`	Read-only relocations (partial RELRO)
`-Wl,-z,now`	Immediate binding (full RELRO, protects GOT)
`-Wl,-z,noexecstack`	Non-executable stack

Control Flow Integrity

-fcf-protection=full    # GCC/Clang on x86 (Intel CET)

Hardened libc++ (Clang/libc++)

libc++ provides hardening modes that add bounds-checking to standard containers with minimal overhead.

Modes

Mode	Flag	What It Checks	Overhead
Fast	`_LIBCPP_HARDENING_MODE_FAST`	Bounds on `[]`, `front()`, `back()`	~0.3%
Extensive	`_LIBCPP_HARDENING_MODE_EXTENSIVE`	Fast + iterator validity, internal invariants	Higher
Debug	`_LIBCPP_HARDENING_MODE_DEBUG`	All checks including O(n) validations	Significant

How to Enable

-D_LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_FAST

Recommendation

All builds: Enable _FAST mode — Google measured 0.3% overhead across their fleet
Security-critical code: Enable _EXTENSIVE mode
Development/testing: Enable _DEBUG mode

Google's Results

Deployed across Chrome (2022) and entire server fleet:

~0.3% average performance overhead
1000+ previously undetected bugs found
30% reduction in production segfault rate

Sanitizers

Runtime instrumentation for detecting bugs that static analysis misses.

AddressSanitizer (ASan)

Detects: heap/stack buffer overflow, use-after-free, double-free, memory leaks.

-fsanitize=address -fno-omit-frame-pointer

Overhead: ~2x slowdown, ~3x memory. Use in CI, not production.

UndefinedBehaviorSanitizer (UBSan)

Detects: signed integer overflow, null pointer dereference, division by zero, misaligned access, out-of-bounds array access.

-fsanitize=undefined -fno-sanitize-recover=all

Overhead: minimal (~5-10%). Safe for most CI runs.

ThreadSanitizer (TSan)

Detects: data races, lock-order inversions, deadlocks.

-fsanitize=thread

Overhead: ~5-15x slowdown. Use for concurrent code testing.

MemorySanitizer (MSan)

Detects: reads of uninitialized memory.

-fsanitize=memory -fno-omit-frame-pointer

Overhead: ~3x slowdown. Clang-only. Requires all linked code to be instrumented.

Combining Sanitizers

Combination	Compatible?
ASan + UBSan	Yes — recommended default
ASan + TSan	No — mutually exclusive
ASan + MSan	No — mutually exclusive
TSan + UBSan	Yes
MSan + UBSan	Yes

CI Integration

Recommended CI matrix:

1. Build with ASan + UBSan → run all tests
2. Build with TSan → run concurrency tests
3. (Optional) Build with MSan → run all tests (Clang only)

Production: GWP-ASan

For production environments where full ASan is too expensive, use GWP-ASan — a sampling-based allocator that detects heap bugs with near-zero overhead.

Enabled by default in Chrome, Android, Apple platforms
Catches use-after-free and buffer overflow in production
See Trail of Bits guide to GWP-ASan

Verifying Hardening

Don't trust that flags are applied — verify the binary:

checksec

checksec --file=./my_binary

Checks: RELRO, stack canary, NX, PIE, FORTIFY.

readelf

# Check for RELRO
readelf -l ./my_binary | grep GNU_RELRO

# Check for stack canary symbols
readelf -s ./my_binary | grep __stack_chk

# Check for FORTIFY
readelf -s ./my_binary | grep _chk

Compiler Explorer

For quick verification during development, compile on Compiler Explorer and inspect the generated assembly for canary checks and fortified function calls.

Complete Hardened Compilation Example

# GCC
g++ -std=c++23 \
    -Wall -Wextra -Wpedantic -Werror -Wconversion \
    -D_FORTIFY_SOURCE=3 -O2 \
    -fstack-protector-strong -fstack-clash-protection \
    -ftrivial-auto-var-init=zero \
    -fcf-protection=full \
    -fPIE -pie \
    -Wl,-z,relro,-z,now -Wl,-z,noexecstack \
    main.cpp -o my_binary

# Clang (with hardened libc++)
clang++ -std=c++23 -stdlib=libc++ \
    -Wall -Wextra -Wpedantic -Werror -Wconversion \
    -Wunsafe-buffer-usage \
    -D_FORTIFY_SOURCE=3 -O2 \
    -D_LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_FAST \
    -fstack-protector-strong -fstack-clash-protection \
    -ftrivial-auto-var-init=zero \
    -fcf-protection=full \
    -fPIE -pie \
    -Wl,-z,relro,-z,now -Wl,-z,noexecstack \
    main.cpp -o my_binary

References

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Implement
Matt Pocock· Community
A structured workflow for implementing software tasks from specifications or tickets.
Software developmentClaude CodeClaude appsOpenAI Codex+14 more
MITGitHub stars of the source repository317.5k
Source Driven Development
Addy Osmani· Community
A rigorous process for grounding code implementation in official, version-specific documentation to ensure accuracy and avoid outdated patterns.
Software developmentClaude CodeClaude appsOpenAI Codex+14 more
MITGitHub stars of the source repository113.9k
Write Swift
Emil Kowalski· Community
A comprehensive guide to writing modern, safe, and performant Swift code following the language's latest idioms and concurrency models.
Software developmentClaude CodeClaude appsOpenAI Codex+14 more
MITGitHub stars of the source repository54.3k
Cardputer Buddy
AnthropicOfficial
Iterate on the Cardputer-Adv MicroPython app bundle (Claude Buddy, Snake, Hello) after the device is already provisioned via m5-onboard. Use when the user wants to add a new app, push a single changed .py without re-flashing, watch device serial logs, or run a one-shot REPL command. Trigger on "add an app", "push to the cardputer", "tail the device", "run on the device", or follow-up work after /maker-setup.
Software developmentClaude CodeClaude appsOpenAI Codex+14 more
Apache-2.0GitHub stars of the source repository46.3k
Typescript Pro
Seth Hobson· Community
An expert TypeScript persona focused on advanced typing, enterprise architecture, and strict type safety.
Software developmentClaude Code
MITGitHub stars of the source repository42.3k
Scala Pro
Seth Hobson· Community
An expert Scala engineer persona specializing in functional programming, distributed systems, and enterprise-grade architecture.
Software developmentClaude Code
MITGitHub stars of the source repository42.3k

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download modern-cpp.zip