Master Modern C++ Development

Cpp Pro is a skill that positions the model as a C++ programming expert specializing in modern C++ and high-performance software. It writes idiomatic C++ using modern language features, RAII, smart pointers and STL algorithms, and it handles templates, move semantics and performance optimization.

Its focus areas are modern C++ features across C++11, 14, 17, 20 and 23; RAII and smart pointers (unique_ptr and shared_ptr); template metaprogramming and concepts; move semantics and perfect forwarding; STL algorithms and containers; concurrency with std::thread and atomics; and exception safety guarantees.

The approach is a short list of habits:

1. Prefer stack allocation and RAII over manual memory management.
2. Use smart pointers when heap allocation is necessary.
3. Follow the Rule of Zero, Three or Five.
4. Use const correctness and constexpr where applicable.
5. Leverage STL algorithms over raw loops.
6. Profile with tools like perf and VTune.

The skill closes with two principles: follow the C++ Core Guidelines, and prefer compile-time errors over runtime errors.

A bundled implementation playbook backs these habits with short code samples. It covers RAII and resource management (wrap raw resources in manager objects so cleanup happens on scope exit, for example a std::make_unique array that is freed automatically), smart pointer ownership (unique_ptr for exclusive ownership, shared_ptr for ownership shared across components, weak_ptr to break circular reference cycles), and concurrency safety with RAII-style locks such as std::lock_guard or std::unique_lock:

void update() {
    std::lock_guard<std::mutex> lock(mutex_); // Released automatically
    // thread-safe logic
}

The playbook also shows move semantics, where a function takes an rvalue reference and uses std::move to transfer ownership without a copy, and modern STL algorithms, where std::ranges::sort from C++20 replaces a manual loop for cleaner, safer iteration.

Use it when you are writing or reviewing C++ that should follow modern practice, from resource management and templates to scoped locking and performance work.

Do not use it when the task is unrelated to C++ or needs a different domain or tool outside this scope. The skill states that its output is not a substitute for environment-specific validation, testing or expert review, and that you should stop and ask for clarification if required inputs, permissions, safety boundaries or success criteria are missing.

The input is a C++ task: goals, constraints and required inputs, which the skill asks you to clarify before it applies best practices and validates the outcome.

The expected output is a set of concrete artifacts: modern C++ code following best practices; a CMakeLists.txt with the appropriate C++ standard; header files with proper include guards or pragma once; unit tests using Google Test or Catch2; AddressSanitizer and ThreadSanitizer clean output; performance benchmarks using Google Benchmark; and clear documentation of template interfaces.

C++ developers who want idiomatic, modern, resource-safe code with tests, sanitizer checks and benchmarks delivered alongside it.