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.

1.38x

Quality

77%

Does it follow best practices?

Impact

94%

1.38x

Average score across 3 eval scenarios

Securityby

Passed

No known issues

Fix and improve this skill with Tessl

tessl review fix ./skills/abstract-trace-summarizer/SKILL.md

Quality

Content

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

Description

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

Validation

100%

Warnings & errors only

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: 4 months ago

Table of Contents

Discovery Implementation Validation

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.