cpp-coding-standards
by affaan-mcpp-coding-standards is a C++ coding standards guide based on the C++ Core Guidelines. Use it for writing, reviewing, and refactoring modern C++ with a focus on safety, clarity, maintainability, RAII, type safety, and good design. Ideal for cpp-coding-standards for Code Review and practical team decisions.
This skill scores 78/100, which means it is worth listing for directory users: it has real workflow value for C++ writing, review, and refactoring, and gives enough guidance to be more actionable than a generic prompt. Users should still expect a mostly document-only skill with limited tooling and some adoption friction around how to apply it in specific codebases.
- Strong triggerability: the frontmatter explicitly says to use it when writing, reviewing, or refactoring C++ code, which makes activation straightforward.
- Good operational depth: the body is substantial (22k chars) with many headings and explicit sections for when to use/not use, principles, and constraints.
- High agent leverage for modern C++ decisions: it focuses on RAII, immutability, type safety, and feature-choice guidance such as `enum` vs `enum class` and raw pointers vs smart pointers.
- No install command or companion tooling, so users get guidance only and must wire it into their own workflow manually.
- No support files, scripts, or references in the repository, which limits verification, examples, and executable enforcement beyond the markdown content.
Overview of cpp-coding-standards skill
What cpp-coding-standards does
The cpp-coding-standards skill is a C++ coding standards guide built around the C++ Core Guidelines. It helps you write, review, and refactor modern C++ with a focus on safety, clarity, and maintainability rather than style trivia.
Who should use it
Use this cpp-coding-standards skill if you work on C++17/20/23 code and need a practical rule set for new code, code review, or cleanup work. It is especially useful for teams deciding between language features, such as enum vs enum class, raw pointers vs smart pointers, or const vs mutable design.
When it is a strong fit
This skill is a good fit when you want a consistent basis for architecture, API design, and review comments. It is also useful when you need a shared cpp-coding-standards guide for enforcing RAII, type safety, immutability, and readable interfaces across a codebase.
Where it is not a fit
It is not a drop-in rule set for non-C++ projects, and it may need selective adaptation for legacy C or hardware-constrained embedded code. If your environment cannot adopt modern C++ features, the skill still offers ideas, but not every rule should be applied as-is.
How to Use cpp-coding-standards skill
Install and inspect the source
Install with npx skills add affaan-m/everything-claude-code --skill cpp-coding-standards. After installation, read SKILL.md first, then check whether the repo has supporting files such as README.md, AGENTS.md, metadata.json, or rules/, references/, and resources/ folders. In this repo, SKILL.md is the main source, so most of the value is in the guideline text itself.
Give the skill a concrete C++ job
The cpp-coding-standards usage works best when you provide a specific task, not a vague request for “better code.” Say what you are writing or changing, what C++ version you target, and any constraints that matter. For example: “Review this service class for RAII, ownership, and exception safety under C++20” or “Refactor this parser to use std::optional and eliminate raw owning pointers.”
Read the rule sections that drive decisions
The most useful sections to read first are When to Use, When NOT to Use, and the cross-cutting principles. Those sections tell you what the skill optimizes for and where it expects tradeoffs. If you are using the cpp-coding-standards skill for Code Review, focus on the principles that map to ownership, lifetime, intent, and complexity before worrying about cosmetic consistency.
Turn a rough goal into a better prompt
A stronger prompt names the code shape, the risk, and the desired outcome. Instead of “make this more modern,” use: “Review these classes for ownership, lifetime, and interface clarity; prefer RAII, const correctness, and explicit types; avoid changes that increase template complexity.” That kind of input gives the skill enough context to produce actionable guidance instead of generic advice.
cpp-coding-standards skill FAQ
Is cpp-coding-standards only for code review?
No. The cpp-coding-standards skill also works for implementation and refactoring decisions. Code review is one of the best use cases, but the same guidance helps when you are designing APIs, choosing abstractions, or cleaning up older code.
Do I need to know the C++ Core Guidelines first?
No. The skill is useful even if you have not read the full guidelines. That said, if your team already follows the C++ Core Guidelines, this skill will feel like a practical operational layer rather than a new standard.
Can I use it for older C++ code?
Yes, but with judgment. The skill is strongest on modern C++ codebases; for older code, use it to identify safe upgrade paths rather than forcing every guideline immediately.
Is it better than a generic prompt?
Usually yes, because the cpp-coding-standards skill gives you a stable standard for tradeoffs, not just a one-off opinion. That makes it more reliable when you need consistent cpp-coding-standards for Code Review across multiple files or contributors.
How to Improve cpp-coding-standards skill
Provide the missing context up front
The biggest quality boost comes from telling the skill your compiler standard, target platform, and code ownership constraints. Mention whether exceptions are allowed, whether allocations are acceptable, and whether you can change public APIs. Those details prevent advice that is technically correct but unusable.
Ask for the decision you actually need
The skill is strongest when you ask for a concrete output: review comments, refactoring plan, risk analysis, or a rewritten snippet. If you only ask for “best practices,” you will get broad guidance; if you ask “Should this API return std::unique_ptr or a reference, and why?”, you get a decision you can act on.
Watch for common failure modes
The main failure mode is over-applying modern C++ rules to code that has different constraints. Another is underspecifying ownership, lifetime, or threading, which makes it hard to judge whether a rule is safe. Tighten the prompt by naming what must not change and what behavior must be preserved.
Iterate from principle to patch
Start with a standards-based review, then request a second pass that turns the findings into edits. For example: “Now rewrite only the ownership-related parts, keep the public interface stable, and preserve exception guarantees.” That workflow makes the cpp-coding-standards skill more useful than a one-shot style pass and keeps the final result aligned with your repository.