tdg-personal/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.
66
82%
Does it follow best practices?
Impact
—
No eval scenarios have been run
Passed
No known issues
Quality
Discovery
82%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 that clearly communicates both purpose and trigger conditions. Its main weakness is a lack of specific concrete actions—it describes the domain and intent well but doesn't enumerate particular capabilities (e.g., enforcing RAII, flagging unsafe casts, recommending smart pointers). The distinctiveness could also be improved to reduce potential overlap with general C++ coding skills.
Suggestions
Add specific concrete actions the skill performs, e.g., 'Enforces RAII patterns, flags raw pointer usage, recommends smart pointers, checks const-correctness, and suggests modern C++ idioms.'
Improve distinctiveness by clarifying how this differs from general C++ coding assistance, e.g., 'Focuses specifically on guideline compliance rather than general C++ development.'
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Names the domain (C++ coding standards) and references a specific source (C++ Core Guidelines), but does not list concrete actions beyond general verbs like 'writing, reviewing, or refactoring'. It lacks specific capabilities such as 'enforce RAII patterns, flag raw pointer usage, suggest smart pointer replacements'. | 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 | While the reference to C++ Core Guidelines specifically is distinctive, this could overlap with a general C++ coding skill or a code review skill. The scope of 'writing, reviewing, or refactoring C++ code' is quite broad and could conflict with other C++-related skills. | 2 / 3 |
Total | 10 / 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 weakness is verbosity — it's a large monolithic document that restates many concepts Claude already understands about C++, and some rule summary tables add little beyond what the guideline names convey. The checklist at the end is a strong practical addition, but the skill would benefit from being condensed into a leaner overview with optional deep-dive files.
Suggestions
Trim rule summary tables that merely restate guideline titles — keep only rules where the summary adds non-obvious guidance beyond what Claude already knows about C++.
Split detailed per-section code examples into separate reference files (e.g., CLASSES.md, CONCURRENCY.md) and keep SKILL.md as a concise overview with the cross-cutting principles and checklist.
Add a brief workflow section describing how to apply these standards iteratively: e.g., 1) Write code, 2) Run through checklist, 3) Fix violations, 4) Re-verify — especially for refactoring scenarios.
| 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 with specific rule references. | 3 / 3 |
Workflow Clarity | The final checklist provides a clear verification workflow for reviewing code, but the skill lacks explicit multi-step workflows for applying these standards during code writing or refactoring. There are no feedback loops or sequenced processes for how to iteratively apply and validate compliance with these guidelines. | 2 / 3 |
Progressive Disclosure | The content is well-structured with clear section headers and logical grouping, but it's a monolithic document with no references to supporting files. Given its length (~500+ lines), sections like the detailed code examples for each guideline category could be split into separate reference files, with the main SKILL.md serving as a concise overview. | 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 | |
Reviewed
Table of Contents