cpp-pro

Refactoring C++20 code involves applying concepts for template constraints and ranges for composable pipelines, enforcing zero-overhead abstractions. This Skill guides you through modernizing large codebases by replacing legacy patterns with C++ Core Guidelines-compliant designs using RAII and smart pointers.

Debugging memory management issues in modern C++ requires applying RAII, smart pointers, and sanitizers to identify leaks and dangling pointers. This Skill guides you through high-performance memory workflows by integrating static analysis and robust testing practices to verify correctness across large codebases.

Coroutines in high-performance C++ enable asynchronous execution without callback overhead, supporting scalable concurrency. This Skill analyzes your C++20/23 coroutine design to ensure zero-overhead abstractions and proper memory management while addressing performance bottlenecks in critical execution paths.

CMake and static analysis tools configure and verify C++23 build systems by enabling sanitizers and enforcing correctness checks. This Skill evaluates your build tooling setup to ensure maintainable architectures, robust testing practices, and zero-overhead abstractions across large codebases.

Template metaprogramming and SIMD optimization are needed when addressing critical performance bottlenecks in high-performance C++ systems. This Skill analyzes your performance paths and guides policy-based design with concepts to achieve zero-overhead abstractions and correct concurrency management.

Concurrency issues in modern C++ persist when smart pointers manage lifetime but thread synchronization is incorrect or data races occur. This Skill analyzes your concurrency design against the C++ Core Guidelines, applying sanitizers and static analysis to debug and verify correctness.