control-flow-abstraction-generator

Generate abstract Control Flow Graph (CFG) representations of programs showing loops, branches, and function calls for static analysis or verification. Use when users need to: (1) Visualize program control flow structure, (2) Generate CFGs for static analysis tools, (3) Create control flow abstractions for formal verification, (4) Analyze program paths and reachability, (5) Document program structure. Supports both function-level (intraprocedural) and program-level (interprocedural) analysis with multiple output formats (textual, DOT/Graphviz, JSON).

Install with Tessl CLI

npx tessl i github:ArabelaTso/Skills-4-SE --skill control-flow-abstraction-generator

What are skills?

Review — 86%

Does it follow best practices?

If you maintain this skill, you can automatically optimize it using the tessl CLI to improve its score:

npx tessl skill review --optimize ./path/to/skill

Learn more

Validation — 10 / 11 Passed

Validation for skill structure

SKILL.md

Review

Evals

Discovery

100%

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 an excellent skill description that excels across all dimensions. It provides specific concrete actions, comprehensive trigger terms covering both technical jargon and natural language, explicit 'Use when' guidance with enumerated scenarios, and a clearly distinctive niche in program analysis. The description uses proper third-person voice throughout and balances technical precision with accessibility.

Dimension	Reasoning	Score
Specificity	Lists multiple specific concrete actions: 'Generate abstract Control Flow Graph (CFG) representations', 'showing loops, branches, and function calls', 'Visualize program control flow structure', 'Generate CFGs for static analysis tools', 'Create control flow abstractions for formal verification', 'Analyze program paths and reachability'. Also specifies output formats (textual, DOT/Graphviz, JSON) and analysis levels (intraprocedural, interprocedural).	3 / 3
Completeness	Clearly answers both what (generate CFG representations showing loops, branches, function calls) AND when with explicit numbered triggers: 'Use when users need to: (1) Visualize program control flow structure, (2) Generate CFGs for static analysis tools...' etc. The 'Use when' clause is explicit and comprehensive.	3 / 3
Trigger Term Quality	Includes strong natural keywords users would say: 'Control Flow Graph', 'CFG', 'static analysis', 'verification', 'loops', 'branches', 'function calls', 'program paths', 'reachability', 'DOT', 'Graphviz'. Covers both acronyms and full terms, plus common output format names.	3 / 3
Distinctiveness Conflict Risk	Highly distinctive niche focused specifically on Control Flow Graphs and static analysis. The technical domain (CFGs, formal verification, intraprocedural/interprocedural analysis) is narrow enough to avoid conflicts with general code analysis or documentation skills.	3 / 3
	Total	12 / 12 Passed

Implementation

72%

Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.

This is a well-structured skill with excellent actionability through multiple complete examples in various output formats. The progressive disclosure is handled well with clear references to external documentation. However, it could be more concise by removing explanations of concepts Claude already knows (CFG properties, basic definitions) and would benefit from explicit validation steps in the workflow.

Suggestions

Remove or significantly condense the 'CFG Properties' section (dominance, post-dominance, reachability, SCCs) as these are standard CS concepts Claude already knows

Add validation checkpoints to the workflow, such as 'Verify all nodes are reachable from ENTRY' and 'Check that all branches have corresponding merge nodes' as explicit steps rather than just tips

Condense the Step 2 and Step 3 node/edge type definitions into a compact table format rather than verbose bullet lists

Dimension	Reasoning	Score
Conciseness	The skill is moderately efficient but includes some unnecessary explanation. The CFG Properties section (dominance, post-dominance, reachability, SCCs) explains concepts Claude already knows. The step-by-step workflow sections are somewhat verbose with definitions that could be more compact.	2 / 3
Actionability	Excellent actionability with multiple complete, executable examples including Python code, textual CFG output, visual ASCII representations, and valid DOT/Graphviz code that can be directly used. The JSON format example is also complete and usable.	3 / 3
Workflow Clarity	The 5-step workflow is clearly sequenced, but lacks explicit validation checkpoints. There's no guidance on verifying CFG correctness, handling malformed input, or error recovery. For a skill generating structured output for analysis tools, validation steps would be important.	2 / 3
Progressive Disclosure	Good structure with clear overview, detailed examples inline, and appropriate references to external files (cfg_patterns.md) for comprehensive patterns. The 'Load this reference when' section clearly signals when to access additional content. Navigation is straightforward.	3 / 3
	Total	10 / 12 Passed

Validation

90%

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 — 10 / 11 Passed

Validation for skill structure

Criteria	Description	Result
skill_md_line_count	SKILL.md is long (515 lines); consider splitting into references/ and linking	Warning

	Total	10 / 11 Passed

Reviewed: about 12 hours 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.