abstract-trace-summarizer
Performs abstract interpretation to produce summarized execution traces and high-level program behavior representations. Highlights key control flow paths, variable relationships, loop invariants, function summaries, and potential runtime states using abstract domains (intervals, signs, nullness, etc.). Use when analyzing program behavior, understanding execution paths, computing loop invariants, tracking variable ranges, detecting potential runtime errors, or generating program summaries without concrete execution.
84
77%
Does it follow best practices?
Impact
94%
1.38xAverage score across 3 eval scenarios
Passed
No known issues
Optimize this skill with Tessl
npx tessl skill review --optimize ./skills/abstract-trace-summarizer/SKILL.mdQuality
Discovery
85%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, technically detailed description that clearly explains what the skill does and when to use it. The main weakness is the heavy reliance on academic/technical jargon that users may not naturally use when requesting this functionality. The description would benefit from including more accessible trigger terms alongside the technical ones.
Suggestions
Add more accessible trigger terms that users might naturally say, such as 'static analysis', 'code analysis', 'analyze code without running it', or 'find bugs statically'
Consider adding common use case phrases like 'verify program correctness' or 'prove program properties' to capture users who may not know the term 'abstract interpretation'
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Lists multiple specific concrete actions: 'summarized execution traces', 'high-level program behavior representations', 'control flow paths', 'variable relationships', 'loop invariants', 'function summaries', 'runtime states', and specific abstract domains like 'intervals, signs, nullness'. | 3 / 3 |
Completeness | Clearly answers both what (performs abstract interpretation, produces traces, highlights control flow, etc.) AND when with explicit 'Use when...' clause covering multiple trigger scenarios: analyzing program behavior, understanding execution paths, computing loop invariants, tracking variable ranges, detecting runtime errors, generating program summaries. | 3 / 3 |
Trigger Term Quality | Includes some relevant technical terms like 'loop invariants', 'variable ranges', 'runtime errors', 'program summaries', but uses heavy jargon ('abstract interpretation', 'abstract domains') that users may not naturally say. Missing simpler variations like 'static analysis', 'code analysis', or 'program analysis'. | 2 / 3 |
Distinctiveness Conflict Risk | Highly specialized niche focusing specifically on abstract interpretation and static program analysis. The specific terminology (abstract domains, loop invariants, abstract interpretation) clearly distinguishes it from general code analysis or debugging skills. | 3 / 3 |
Total | 11 / 12 Passed |
Implementation
70%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This skill provides a thorough framework for abstract interpretation and trace summarization with excellent workflow structure and progressive disclosure. However, it leans toward academic explanation rather than actionable implementation, with pseudocode and mathematical notation instead of executable code. The content could be more concise by assuming Claude's familiarity with foundational concepts.
Suggestions
Replace pseudocode examples with executable Python implementations that demonstrate actual abstract interpretation (e.g., a working interval analysis)
Condense the abstract domain explanations into a reference table rather than prose descriptions, assuming Claude understands lattice theory basics
Add concrete tool recommendations or library references (e.g., Frama-C, IKOS, or Python AST libraries) to make the skill more immediately actionable
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill is comprehensive but verbose in places. It explains concepts like lattice operations and abstract domains that Claude likely understands, and includes extensive explanatory text that could be condensed. However, it's not egregiously padded. | 2 / 3 |
Actionability | Provides conceptual guidance and pseudocode-style examples rather than fully executable code. The patterns section shows abstract notation (e.g., 'sum ∈ [0,+∞]') but lacks concrete, copy-paste ready implementations of the analysis techniques. | 2 / 3 |
Workflow Clarity | The workflow is clearly sequenced with numbered steps (1-7) covering the full analysis pipeline. Each phase has explicit sub-steps, and the loop analysis includes proper fixpoint computation with widening/narrowing. Validation is implicit in the iterative convergence process. | 3 / 3 |
Progressive Disclosure | Well-structured with clear sections progressing from overview to detailed techniques. References to external files (references/abstract_interpretation.md, references/examples.md) are clearly signaled at the end. Content is appropriately organized with headers and subsections. | 3 / 3 |
Total | 10 / 12 Passed |
Validation
100%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 11 / 11 Passed
Validation for skill structure
No warnings or errors.
- Repository
- ArabelaTso/Skills-4-SE
- Commit
0f00a4f
- 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.