hpc-patterns
High-performance computing patterns for C++20 including cache-friendly data structures, SIMD vectorization, memory management, thread parallelism, lock-free data structures, and NUMA-aware allocation.
75
70%
Does it follow best practices?
Impact
Pending
No eval scenarios have been run
Passed
No known issues
Optimize this skill with Tessl
npx tessl skill review --optimize ./skills/hpc-patterns/SKILL.mdQuality
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 strong description with excellent specificity and distinctive technical terminology that clearly carves out a niche in high-performance C++20 computing. The main weakness is the absence of an explicit 'Use when...' clause, which would help Claude know exactly when to select this skill over others. Adding trigger guidance would elevate this from good to excellent.
Suggestions
Add a 'Use when...' clause such as 'Use when the user asks about C++ performance optimization, SIMD intrinsics, cache optimization, lock-free programming, NUMA topology, or high-performance computing patterns.'
Consider adding file extension triggers like '.cpp', '.hpp' or mentioning common libraries/tools (e.g., 'Intel TBB', 'std::atomic') to broaden keyword matching.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Lists multiple specific concrete actions/capabilities: cache-friendly data structures, SIMD vectorization, memory management, thread parallelism, lock-free data structures, and NUMA-aware allocation. These are all concrete, well-defined technical domains. | 3 / 3 |
Completeness | Clearly answers 'what does this do' with specific capabilities, but lacks an explicit 'Use when...' clause or equivalent trigger guidance. Per the rubric, a missing 'Use when...' clause caps completeness at 2. | 2 / 3 |
Trigger Term Quality | Includes strong natural keywords users would use: 'C++20', 'cache-friendly', 'SIMD', 'vectorization', 'lock-free', 'NUMA', 'thread parallelism', 'memory management', 'high-performance computing'. These are terms developers naturally use when seeking help with performance optimization in C++. | 3 / 3 |
Distinctiveness Conflict Risk | The combination of C++20, HPC patterns, and specific techniques like SIMD, NUMA-aware allocation, and lock-free data structures creates a very distinct niche that is unlikely to conflict with other skills. This is highly specialized. | 3 / 3 |
Total | 11 / 12 Passed |
Implementation
57%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This skill provides excellent, actionable C++20 HPC code patterns covering a comprehensive range of topics from cache optimization to GPU offloading. However, it suffers from being a monolithic reference document (~400+ lines) with no progressive disclosure or external file references, which makes it token-expensive when loaded into context. The workflow guidance is present but lacks explicit validation checkpoints for the individual optimization patterns.
Suggestions
Split the content into separate reference files (e.g., CACHE.md, SIMD.md, THREADING.md, MPI.md) and keep SKILL.md as a concise overview with links to each topic
Add explicit validation/verification steps within patterns—e.g., after SIMD optimization, verify correctness against scalar version; after lock-free implementation, test with ThreadSanitizer
Trim standard implementations Claude already knows (e.g., basic ThreadPool, Timer class) to brief references or remove them, focusing on HPC-specific nuances
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The content is mostly efficient with good code examples, but it's quite long (~400 lines) and some patterns like the ThreadPool and MemoryPool are standard implementations Claude would know. The BAD/GOOD comments and some inline explanations add minor verbosity, though most code earns its place as reference patterns. | 2 / 3 |
Actionability | Nearly all guidance is concrete, executable C++ code with complete implementations. Code examples are copy-paste ready including the aligned allocator, thread pool, lock-free stack, SIMD intrinsics, MPI patterns, and benchmark integration with CMake. Bash commands for perf profiling are specific and directly usable. | 3 / 3 |
Workflow Clarity | The 'Key Principles' at the end provide a high-level optimization workflow (measure → profile → optimize data layout → parallelize → benchmark → verify), but there are no explicit validation checkpoints or feedback loops within the individual patterns. For operations like NUMA allocation or lock-free data structures where correctness verification is critical, no validation steps are provided. | 2 / 3 |
Progressive Disclosure | The entire skill is a monolithic wall of code examples with no references to external files for detailed content. All patterns—cache, SIMD, memory, threading, lock-free, NUMA, MPI, GPU—are inlined in a single document. This would benefit greatly from splitting into separate reference files per topic with a concise overview in the main skill. | 1 / 3 |
Total | 8 / 12 Passed |
Validation
90%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 10 / 11 Passed
Validation for skill structure
| Criteria | Description | Result |
|---|---|---|
skill_md_line_count | SKILL.md is long (608 lines); consider splitting into references/ and linking | Warning |
Total | 10 / 11 Passed | |
- Repository
- ysyecust/everything-claude-code
- Commit
79cc4e3
- 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.