frontend-to-ir

Lower a toy language AST to LLVM 22 IR using IRBuilder. Covers project setup, AST node types, expression lowering, control flow, functions, structs, and applying mem2reg.

Quality

72%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide

Securityby

Passed

No findings from the security scan

Fix and improve this skill with Tessl

tessl review fix ./tiles/tessl-llvm/skills/frontend-to-ir/SKILL.md

Quality

Content

77%Scale 1-3

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

This is a strong, highly actionable skill that provides a complete, executable walkthrough of lowering a toy language AST to LLVM IR. Its main weakness is length — the monolithic inline presentation of all code could benefit from splitting detailed sections (expression/statement emission, pass pipeline) into referenced files. The 'Common mistakes' section is excellent and adds significant practical value.

Suggestions

Split the detailed expression emitter (Step 3) and statement emitter (Step 4) into a referenced file like LOWERING_DETAILS.md, keeping only a representative subset inline in SKILL.md.

Consider trimming obvious switch cases (e.g., BoolLit, FloatLit) that Claude can infer from the pattern established by IntLit, to reduce token usage.

Dimension	Reasoning	Score
Conciseness	The skill is mostly efficient with executable code examples and minimal prose, but it's quite long (~250 lines of code) and some patterns (like the full expression/statement switch blocks) could be trimmed since Claude understands how to extend switch cases. The introductory sentence explaining when to use the skill is fine but the sheer volume of code is borderline verbose for a skill file.	2 / 3
Actionability	Every step contains concrete, executable C++ code using real LLVM 22 APIs (IRBuilder, PassBuilder, etc.). The code is copy-paste ready with proper includes, function signatures, and complete implementations covering types, expressions, statements, control flow, and optimization passes.	3 / 3
Workflow Clarity	The 8-step workflow (Step 0-7) is clearly sequenced from module setup through type mapping, function emission, expressions, statements, module assembly, optimization passes, and output. Validation checkpoints are explicit: verifyFunction after each function, verifyModule after full emission, and the 'Common mistakes' section serves as a verification checklist with feedback guidance.	3 / 3
Progressive Disclosure	The content is entirely inline with no references to separate files for advanced topics (e.g., struct type creation, TargetMachine setup is mentioned but only briefly). For a skill this long (~250+ lines), some content like the full expression/statement emitters or the pass pipeline could be split into referenced files. The brief mention of 'see out-of-tree-setup skill' is a good signal but underutilized.	2 / 3
	Total	10 / 12 Passed

Description

67%Scale 1-3

Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.

The description is technically specific and covers a well-defined niche with concrete actions, making it highly distinctive. Its main weakness is the absence of an explicit 'Use when...' clause, which would help Claude know exactly when to select this skill. Adding a few more natural trigger terms that users might use when seeking compiler/codegen help would also improve discoverability.

Suggestions

Add an explicit 'Use when...' clause, e.g., 'Use when the user asks about LLVM code generation, compiler backends, lowering an AST to IR, or building a toy compiler.'

Include additional natural trigger terms like 'code generation', 'codegen', 'compiler', 'intermediate representation', and 'LLVM backend' to improve keyword coverage.

Dimension	Reasoning	Score
Specificity	Lists multiple specific concrete actions: lowering AST to LLVM 22 IR using IRBuilder, project setup, AST node types, expression lowering, control flow, functions, structs, and applying mem2reg.	3 / 3
Completeness	Clearly answers 'what does this do' with specific capabilities, but lacks an explicit 'Use when...' clause or equivalent trigger guidance, which caps this at 2 per the rubric guidelines.	2 / 3
Trigger Term Quality	Includes relevant technical keywords like 'LLVM', 'IRBuilder', 'AST', 'mem2reg', 'IR', 'control flow', 'structs' that a user working in this domain would use. However, it misses common variations like 'code generation', 'codegen', 'compiler backend', 'LLVM pass', or 'intermediate representation' that users might naturally say.	2 / 3
Distinctiveness Conflict Risk	Highly distinctive niche: lowering a toy language AST to LLVM 22 IR using IRBuilder is very specific and unlikely to conflict with other skills. The combination of LLVM, IRBuilder, AST lowering, and mem2reg creates a clear, unique identity.	3 / 3
	Total	10 / 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: hbarve1/tessl-llvm
Path: tiles/tessl-llvm/skills/frontend-to-ir/SKILL.md
Commit: a251bde

Reviewed: 6 days 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.