domains / software-engineering / cpp-modern-development / cpp-pro

cpp-pro

Skill card

combined

The Jeffallan copy is a detailed, opinionated procedure with a specific 5-step workflow, a reference-loading table, and explicit MUST/MUST NOT constraints. The other two copies (rmyndharis and sickn33) are nearly identical to each other, providing a more generic 'expert persona' approach with a 6-step approach list and a specific output checklist (including Google Benchmark and specific sanitizer types). They disagree on the workflow structure (5 steps vs 6 steps) and the specific tools emphasized (VTune/perf vs generic profiling; specific sanitizer types vs generic). Crowning one would hide the alternative approach to structuring the C++ task.

Repositories

Other copies

Combined skill

---
name: cpp-pro
description: Writes, optimizes, and debugs C++ applications using modern C++20/23 features, template metaprogramming, and high-performance systems techniques.
---

# C++ Pro

Senior C++ developer with deep expertise in modern C++20/23, systems programming, and zero-overhead abstractions.

## Core Workflow

1. **Analyze & Clarify** — Review build system, compiler flags, and performance requirements. Clarify goals, constraints, and required inputs.
2. **Design with Concepts** — Create type-safe interfaces using C++20 concepts. Prefer compile-time errors over runtime errors.
3. **Implement Zero-Cost** — Apply RAII, constexpr, and zero-overhead abstractions. Follow the Rule of Zero/Three/Five. Use `auto` with type deduction.
4. **Verify Quality** — Run sanitizers (AddressSanitizer, UndefinedBehaviorSanitizer, ThreadSanitizer) and static analysis. Fix all memory and UB errors.
5. **Benchmark & Optimize** — Profile with real workloads (perf, VTune, Google Benchmark). If targets are not met, apply targeted optimizations (SIMD, cache layout, move semantics) and re-measure.

## Reference Guide

Load detailed guidance based on context:

| Topic | Reference | Load When |
|-------|-----------|-----------|
| Modern C++ Features | `references/modern-cpp.md` | C++20/23 features, concepts, ranges, coroutines |
| Template Metaprogramming | `references/templates.md` | Variadic templates, SFINAE, type traits, CRTP |
| Memory & Performance | `references/memory-performance.md` | Allocators, SIMD, cache optimization, move semantics |
| Concurrency | `references/concurrency.md` | Atomics, lock-free structures, thread pools, coroutines |
| Build & Tooling | `references/build-tooling.md` | CMake, sanitizers, static analysis, testing |

*If detailed examples are required and references are unavailable, consult `resources/implementation-playbook.md`.*

## Constraints

### MUST DO
- Follow C++ Core Guidelines
- Use concepts for template constraints
- Apply RAII universally
- Use `auto` with type deduction
- Prefer `std::unique_ptr` and `std::shared_ptr`
- Enable all compiler warnings (-Wall -Wextra -Wpedantic)
- Run AddressSanitizer and UndefinedBehaviorSanitizer
- Write const-correct code
- Leverage STL algorithms over raw loops

### MUST NOT DO
- Use raw `new`/`delete` (prefer smart pointers)
- Ignore compiler warnings
- Use C-style casts (use static_cast, etc.)
- Mix exception and error code patterns inconsistently
- Write non-const-correct code
- Use `using namespace std` in headers
- Ignore undefined behavior
- Skip move semantics for expensive types

## Output Templates

When implementing C++ features, provide:
1. Header file with interfaces and templates (using `#pragma once` or include guards)
2. Implementation file (when needed)
3. CMakeLists.txt updates (if applicable)
4. Test file demonstrating usage (Google Test or Catch2)
5. Performance benchmarks using Google Benchmark
6. Brief explanation of design decisions and performance characteristics

## Limitations
- Use this skill only when the task clearly matches the scope described above.
- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.