cpp-coding-standards
C++ coding standards based on the C++ Core Guidelines (isocpp.github.io). Use when writing, reviewing, or refactoring C++ code to enforce modern, safe, and idiomatic practices.
83
77%
Does it follow best practices?
Impact
97%
1.11xAverage score across 3 eval scenarios
Passed
No known issues
Optimize this skill with Tessl
npx tessl skill review --optimize ./skills/cpp-coding-standards/SKILL.mdQuality
Discovery
89%Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.
This is a solid description with clear 'what' and 'when' clauses, good trigger terms, and strong distinctiveness. Its main weakness is that the capabilities are described at a high level ('enforce modern, safe, and idiomatic practices') without listing specific concrete actions or guidelines it covers, which limits specificity.
Suggestions
Add specific concrete actions or guideline areas, e.g., 'Enforces RAII, smart pointer usage, const correctness, bounds safety, and lifetime management rules.'
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Names the domain (C++ coding standards) and references the C++ Core Guidelines, but doesn't list specific concrete actions beyond 'writing, reviewing, or refactoring.' It lacks detail on what specific standards or practices are enforced (e.g., RAII, smart pointers, const correctness). | 2 / 3 |
Completeness | Clearly answers both 'what' (C++ coding standards based on C++ Core Guidelines enforcing modern, safe, idiomatic practices) and 'when' (Use when writing, reviewing, or refactoring C++ code). The 'Use when...' clause is explicit. | 3 / 3 |
Trigger Term Quality | Includes strong natural trigger terms: 'C++', 'coding standards', 'C++ Core Guidelines', 'writing', 'reviewing', 'refactoring', 'modern', 'safe', 'idiomatic'. These are terms users would naturally use when seeking help with C++ best practices. | 3 / 3 |
Distinctiveness Conflict Risk | Highly distinctive — specifically scoped to C++ Core Guidelines, which is a well-known, specific standard. Unlikely to conflict with general coding skills or other language-specific skills due to the explicit C++ and Core Guidelines references. | 3 / 3 |
Total | 11 / 12 Passed |
Implementation
64%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This is a thorough, well-structured C++ coding standards reference with excellent actionability through complete code examples and clear DO/DON'T patterns. Its main weaknesses are verbosity (many rule summary tables restate what Claude already knows about C++ Core Guidelines) and the monolithic structure that could benefit from splitting detailed examples into referenced files. The final checklist is a strong practical addition.
Suggestions
Trim rule summary tables to only include rules where the skill adds non-obvious guidance beyond the rule title — Claude already knows the C++ Core Guidelines and doesn't need every rule number restated.
Split detailed code examples (e.g., full Rule of Five Buffer class, RAII FileHandle, ThreadSafeQueue) into a separate EXAMPLES.md file, keeping only concise snippets inline.
Add a brief workflow section describing how to apply these standards during code review (e.g., 'Start with the checklist, then drill into relevant sections for violations found').
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill is comprehensive and well-organized, but at ~500+ lines it includes substantial content that Claude already knows (e.g., basic C++ concepts, standard library usage patterns). Many rule tables simply restate guideline titles without adding novel insight. However, the code examples are tight and the checklist is efficient. | 2 / 3 |
Actionability | Every section provides fully executable, copy-paste-ready C++ code examples with clear DO/DON'T patterns. The code is complete (not pseudocode), includes proper includes, and demonstrates both correct and incorrect usage. The final checklist is directly actionable for code review. | 3 / 3 |
Workflow Clarity | The checklist at the end provides a clear review workflow, but the skill lacks explicit multi-step processes with validation checkpoints. For a coding standards skill, the workflow is primarily 'apply these rules,' which is presented clearly, but there's no guidance on sequencing (e.g., review order, how to prioritize conflicting guidelines, or iterative refactoring steps). | 2 / 3 |
Progressive Disclosure | The content is well-structured with clear section headers and a logical progression from philosophy to specific domains. However, at this length, detailed sections like the full RAII FileHandle example or the complete Rule of Five Buffer class could be split into referenced files. Everything is inline in a single monolithic document with no external references despite the volume warranting them. | 2 / 3 |
Total | 9 / 12 Passed |
Validation
81%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 9 / 11 Passed
Validation for skill structure
| Criteria | Description | Result |
|---|---|---|
skill_md_line_count | SKILL.md is long (724 lines); consider splitting into references/ and linking | Warning |
frontmatter_unknown_keys | Unknown frontmatter key(s) found; consider removing or moving to metadata | Warning |
Total | 9 / 11 Passed | |
- Repository
- affaan-m/everything-claude-code
- Commit
928076c
- Reviewed
Table of Contents
Is this your skill?
If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.