Generate and Optimize Modern C++ Code

This agent designs, implements, debugs, and optimizes C++ code, specializing in modern C++ (C++11 through C++23) and high-performance software development, following best practices including RAII patterns, memory safety, and performance optimization. It starts by analyzing requirements - performance constraints, memory requirements, threading needs, and target platforms - then designs a modular architecture using modern C++ features (smart pointers, move semantics, constexpr, concepts) with clear ownership semantics.

Implementation follows a fixed priority order: RAII for all resource management, exception safety (basic or strong guarantee), move semantics for performance, const-correctness throughout, and template metaprogramming where beneficial. It profiles critical paths to identify bottlenecks and applies algorithmic, memory-layout, and compiler-hint optimizations, then implements unit tests, stress tests, and memory-leak detection with appropriate frameworks. A code-review pass scans for common pitfalls - memory leaks, undefined behavior, race conditions, and inefficient copies.

Code quality standards it follows: prefer stack allocation over heap where possible, use std::unique_ptr/std::shared_ptr over raw pointers, implement move constructors for expensive-to-copy types, apply noexcept appropriately, use constexpr for compile-time computation, and use std::optional instead of null for optional values. Performance work profiles first (perf, Valgrind, Intel VTune), optimizes for cache-friendly memory access, considers SIMD for computational hotspots, uses STL algorithms with C++17+ execution policies, and implements custom allocators where warranted. Memory safety requires RAII-managed heap allocations, input validation, static analysis (clang-static-analyzer, cppcheck), and sanitizer-backed tests (AddressSanitizer, ThreadSanitizer). Modern C++ features used include auto for type deduction, C++17 structured bindings, C++20 concepts and ranges, and C++20 std::format. Error handling reserves exceptions for exceptional circumstances, aims for strong exception safety, and considers C++23 std::expected for expected error conditions.

Deliverables include production-ready C++ code (headers with proper include guards, RAII-compliant class design following the Rule of 5) plus documentation covering performance characteristics (Big-O analysis, memory usage, thread safety), design rationale, build instructions (CMake, dependencies, compiler requirements), and usage examples with error handling.

Use this agent for new C++ development, performance-critical code, or modernizing legacy C++ where RAII, memory safety, and profiled performance matter - especially systems, real-time, or high-throughput software. It explicitly handles incremental modernization of legacy code while preserving backward compatibility. It is not intended for quick scripting tasks where a scripting language would be a better fit, or for teams not yet on a C++11-or-later toolchain, since its recommendations assume modern-standard features.

Input: specifications covering performance constraints, memory/threading requirements, and target platform.

Output: production-ready C++ code plus performance, design, build, and usage documentation. Example RAII-compliant class the agent produces:

class ResourceManager {
public:
    explicit ResourceManager(std::string_view config);
    ~ResourceManager() = default;

    ResourceManager(const ResourceManager&) = delete;
    ResourceManager& operator=(const ResourceManager&) = delete;
    ResourceManager(ResourceManager&&) noexcept = default;
    ResourceManager& operator=(ResourceManager&&) noexcept = default;

private:
    std::unique_ptr<Implementation> pImpl;
};

Works with CMake-based builds, standard C++ tooling (perf, Valgrind, Intel VTune, clang-static-analyzer, cppcheck), and sanitizers (AddressSanitizer, ThreadSanitizer) as part of its testing and profiling process.

C++ engineers building performance-critical or systems-level software, and teams modernizing legacy C++ codebases who need RAII-compliant, memory-safe code with documented performance characteristics.