AutoGineer
Generated banner for Modern Cpp
Generated logo for Modern Cpp

Modern Cpp

Trail of BitsOfficialPublished by Trail of Bits

  • Skill
  • Guidelines
  • Software development
  • CC-BY-SA-4.0
  • No issues found
Download ZIP

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

  1. Download the skill as a ZIP:

    https://autogineer.com/agent-skills/trailofbits/modern-cpp/download

  2. 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

AvoidUse InsteadWhy
new/deletestd::make_unique, std::make_sharedEliminates leaks, double-free
Raw owning pointersstd::unique_ptr, std::shared_ptrRAII ownership semantics
C arrays (int arr[N])std::array<int, N>Bounds-aware, value semantics
Pointer + length paramsstd::span<T>Non-owning, bounds-checkable
printf / sprintfstd::format, std::printType-safe, no buffer overflow
C-style casts (int)xstatic_cast<int>(x)Explicit intent, auditable
#define constantsconstexpr variablesScoped, typed, debuggable
SFINAE / enable_ifConcepts + requiresReadable constraints and errors
Error codes + out paramsstd::expected<T, E>Composable, type-safe errors
unionstd::variantType-safe, no silent UB
Raw mutex.lock()/unlock()std::scoped_lockException-safe, no deadlocks
std::threadstd::jthreadAuto-join, stop token support
assert() macrocontract_assert (C++26)Visible to tooling, configurable
Manual CRTPDeducing this (C++23)Simpler, no template boilerplate
Macro code generationReflection (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)
FeatureReplacesStandard
Concepts + requiresSFINAE, enable_ifC++20
Ranges + viewsRaw iterator loopsC++20
std::span<T>Pointer + lengthC++20
std::formatsprintf, iostream chainsC++20
Three-way comparison <=>Manual comparison operatorsC++20
std::jthreadstd::thread + manual joinC++20
Designated initializersPositional struct initC++20
std::expected<T,E>Error codes, exceptions at boundariesC++23
std::print / std::printlnprintf, std::cout <<C++23
Deducing thisCRTP, const/non-const duplicationC++23
std::flat_mapstd::map for read-heavy useC++23
Monadic std::optionalNested if-checks on optionalsC++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

RationalizationWhy 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

Read Next

Files

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.

Attribution and licence

Published by
Trail of Bits
Publisher
Trail of Bits (Official)
Source
trailofbits/skills · plugins/modern-cpp/skills/modern-cpp · commit e4dd0bb
Licence
Creative Commons Attribution-ShareAlike 4.0 International (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Trail of Bits or Trail of Bits.

Download ZIP

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