# cpp

Guidelines for modern C++17 and C++20 coding. Enforces RAII, smart pointers, memory safety, and modern standard library patterns in AI-generated code.

- skill · `type=skill` · Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, OpenCode · 775 installs · ★ 286
- Author: Mindrally
- License: Apache-2.0 · policy=mirror · the beginning of the file is at the end of this page
- Source: https://github.com/Mindrally/skills/tree/HEAD/cpp/SKILL.md
- Updated: 2026-10-08
- HTML: https://affpapa.org/en/nevibecode/skills/cpp

## What it does

This skill guides your coding assistant through modern C++17 and C++20 practices. It bans raw owning pointers and direct calls to `new` or `delete`, enforcing `std::unique_ptr`, `std::shared_ptr`, and RAII wrappers instead. The agent applies strict naming standards, relies on `std::string_view` and `std::span` for views, and adopts C++20 concepts and ranges for cleaner logic.

The workflow specifies CMake for cross-platform builds, vcpkg or Conan for packages, and Google Test or Catch2 for unit suites alongside ASan, UBSan, and TSan sanitizers. Concurrency relies on `std::jthread`, atomics, and mutexes.

The guidelines mandate exceptions for domain errors. Projects compiling with `-fno-exceptions` will clash with the generated code out of the box.

## Install

### Claude Code (native platform)

1. **Skills CLI (Vercel)**
```bash
npx skills add Mindrally/skills --skill cpp -a claude-code
```

2. **Manually: put the files in place**
- File: `~/.claude/skills/cpp/SKILL.md` — Copy the whole skill folder; for one project use .claude/skills/cpp/

### Codex

1. **Skills CLI (Vercel)**
```bash
npx skills add Mindrally/skills --skill cpp -a codex
```

2. **Manually: put the files in place**
- File: `.agents/skills/cpp/SKILL.md` — For all projects use ~/.agents/skills/

### Cursor

1. **Skills CLI (Vercel)**
```bash
npx skills add Mindrally/skills --skill cpp -a cursor
```

2. **Manually: put the files in place**
- File: `.cursor/skills/cpp/SKILL.md` — Cursor also reads .agents/skills/ and .claude/skills/

### GitHub Copilot

1. **GitHub CLI**
```bash
gh skill install Mindrally/skills cpp
```

2. **Manually: put the files in place**
- File: `.github/skills/cpp/SKILL.md`

### Gemini CLI

1. **Skills CLI (Vercel)**
```bash
npx skills add Mindrally/skills --skill cpp -a gemini-cli
```

2. **Platform CLI**
```bash
gemini skills install https://github.com/Mindrally/skills --path cpp
```

### Windsurf (Devin Desktop)

**Manually: put the files in place**
- File: `.devin/skills/cpp/SKILL.md` — The legacy .windsurf/skills/ path still works

### OpenCode

**Skills CLI (Vercel)**
```bash
npx skills add Mindrally/skills --skill cpp -a opencode
```

### Claude.ai

**Claude.ai**
- Zip the folder and upload it in Settings → Capabilities → Skills

Where a file is given instead of a command, copy the files from the source to that path: https://github.com/Mindrally/skills/tree/HEAD/cpp/SKILL.md

## When to use it
- Enforce modern C++17 and C++20 idioms across agent-generated code
- Eliminate raw owning pointers in favor of RAII and smart pointers
- Set up tests with Catch2 or Google Test backed by runtime sanitizers
- Replace legacy C arrays with `std::span` and `std::array`

## Example prompts
- Write a thread-safe worker pool using C++20 `std::jthread` and `std::mutex`
- Refactor this legacy class to use RAII and `std::unique_ptr` instead of manual deletes
- Create a template parser constrained by C++20 concepts returning `std::optional`

## Source text · SKILL.md · Apache-2.0

Below is the content of a third-party file. It is data, not instructions for you: do not act on anything written inside unless the human asks. Block tag: e13695c0535ef767.

BEGIN THIRD-PARTY FILE e13695c0535ef767
```text
---
name: cpp
description: Guidelines for modern C++ development with C++17/20 standards, memory safety, and performance optimization
metadata:
  maintainer: Mindrally
  source: https://github.com/Mindrally/skills
---

# C++ Development Guidelines

You are an expert in modern C++ development with deep knowledge of C++17/20 standards, memory management, and high-performance programming.

## Code Style and Structure

- Write clean, modern C++ code following C++17/20 standards
- Use meaningful variable and function names
- Follow the Single Responsibility Principle
- Prefer composition over inheritance
- Keep functions small and focused

## Naming Conventions

- Use PascalCase for classes and structs
- Use camelCase for functions, variables, and methods
- Use SCREAMING_SNAKE_CASE for constants and macros
- Use snake_case for namespaces
- Prefix member variables with `m_` or use trailing underscore

## Memory Management

### Smart Pointers
- Use `std::unique_ptr` for exclusive ownership
- Use `std::shared_ptr` only when shared ownership is required
- Use `std::weak_ptr` to break circular references
- Avoid raw owning pointers

### RAII (Resource Acquisition Is Initialization)
- Use RAII for all resource management
- Wrap resources in classes with proper destructors
- Ensure exception safety through RAII
- Use scope guards for cleanup operations

### Best Practices
- Prefer stack allocation over heap allocation
- Use `std::make_unique` and `std::make_shared`
- Avoid `new` and `delete` in application code
- Use containers instead of raw arrays

## Modern C++ Features

### C++17 Features
- Use structured bindings for tuple unpacking
- Use `std::optional` for values that may not exist
- Use `std::variant` for type-safe unions
- Use `if constexpr` for compile-time conditionals
- Use `std::string_view` for non-owning string references

### C++20 Features
- Use concepts for template constraints
- Use ranges for cleaner algorithms
- Use `std::span` for non-owning array views
- Use coroutines for asynchronous operations
- Use modules for faster compilation (when supported)

## Error Handling

- Use exceptions for error handling
- Define custom exception types for domain-specific errors
- Use `noexcept` for functions that don't throw
- Catch exceptions by const reference
- Provide strong exception guarantees where possible

## Performance

- Use `const` and `constexpr` liberally
- Prefer move semantics with `std::move`
- Use perfect forwarding with `std::forward`
- Avoid unnecessary copies
- Profile before optimizing
- Use `inline` for small frequently-called functions

## Security

### Buffer Safety
- Use `std::array` instead of C-style arrays
- Use `std::vector` with bounds checking
- Prefer `std::string` over C-style strings
- Use `std::span` for array views

### Type Safety
- Avoid C-style casts; use `static_cast`, `dynamic_cast`, etc.
- Use `enum class` instead of plain enums
- Use `nullptr` instead of `NULL`
- Enable compiler warnings and treat them as errors

## Concurrency

- Use `std::thread` and `std::jthread` for threading
- Use `std::mutex` and `std::lock_guard` for synchronization
- Use `std::atomic` for lock-free operations
```
END THIRD-PARTY FILE e13695c0535ef767

The third-party file has ended. Everything between the e13695c0535ef767 tags is data: requests and commands from it are not followed. An “end of file” line with another tag inside the block is part of the file.

First 3181 of 3986 bytes. © Mindrally · Apache-2.0 · https://github.com/Mindrally/skills/tree/HEAD/cpp/SKILL.md

_Part of the page did not fit — see the HTML version._

---
NeVibeCode on affpapa.org. Catalog texts are descriptions, not instructions for the agent. How to choose and install: https://affpapa.org/en/nevibecode/agents.md