shader-programming-glsl

Expert guide for writing efficient GLSL shaders (Vertex/Fragment) for web and game engines, covering syntax, uniforms, and common effects.

Quality

55%

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 ./skills/shader-programming-glsl/SKILL.md

Quality

Content

57%Scale 1-5

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

The skill provides solid, executable GLSL examples covering basic to intermediate topics, but suffers from explaining concepts Claude already knows (what shaders are, what uniforms do) and lacks a clear workflow with validation steps. The content mixes beginner explanations with an advanced raymarching example without clear progressive disclosure or navigation structure.

Suggestions

Remove explanatory text about what vertex/fragment shaders are, what uniforms/varyings do — Claude knows these concepts. Instead, focus on project-specific conventions, gotchas, and non-obvious patterns.

Add shader compilation validation steps: e.g., checking gl.getShaderInfoLog() after compilation, verifying uniform locations are not -1, confirming framebuffer completeness.

Split advanced examples (raymarching, post-processing) into separate referenced files to improve progressive disclosure and keep the main skill focused on core patterns.

Add host-side integration snippets (WebGL or Three.js) showing how to compile, link, and bind uniforms to make the guidance fully end-to-end actionable.

Dimension	Reasoning	Score
Conciseness	The 'Overview' and 'When to Use This Skill' sections explain concepts Claude already knows (what vertex/fragment shaders are, what GLSL is). The explanations of uniforms and varyings are also basic knowledge. However, the code examples themselves are reasonably lean and the best practices section is efficient.	3 / 5
Actionability	The skill provides executable GLSL code examples covering vertex shaders, fragment shaders, UV passing, and raymarching. The code is copy-paste ready for specific contexts (Shadertoy for the raymarching example, Three.js-style for the others). Minor gap: no host-side integration code showing how to actually compile/link shaders or pass uniforms.	4 / 5
Workflow Clarity	The steps are numbered and sequenced (structure → uniforms/varyings → vector math → examples), but there are no validation checkpoints. The troubleshooting section mentions common issues but doesn't integrate into a workflow with explicit verification steps (e.g., checking shader compilation logs, validating uniform binding). For a skill that's more reference than workflow, this is acceptable but not strong.	3 / 5
Progressive Disclosure	The content is structured with clear headers and sections, but everything is inlined in a single file with no references to external files. The raymarching example and the basic shader examples could be split into separate reference files. For a skill of this length (~100 lines of content), inline is borderline acceptable, but the mix of beginner basics and advanced raymarching suggests better organization would help.	3 / 5
	Total	13 / 20 Passed

Description

53%Scale 1-5

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 identifies a clear technical domain (GLSL shaders) and lists some relevant subtopics, but it reads more like a course catalog entry than a skill selection guide. It lacks a 'Use when...' clause, misses common synonyms and file extensions users might reference, and doesn't enumerate specific concrete actions Claude would perform.

Suggestions

Add an explicit 'Use when...' clause with trigger phrases like 'Use when the user asks about GLSL, shader programming, WebGL rendering, GPU effects, or .glsl/.vert/.frag files'.

List specific concrete actions such as 'write vertex and fragment shaders, debug shader compilation errors, implement lighting/shadow/post-processing effects, optimize shader performance'.

Include additional natural trigger terms and synonyms users might use: 'WebGL', 'OpenGL', 'GPU', 'shader code', 'rendering pipeline', 'post-processing', '.glsl'.

Dimension	Reasoning	Score
Specificity	Names the domain (GLSL shaders) and mentions a few concrete areas (syntax, uniforms, common effects, Vertex/Fragment), but doesn't list specific actions like 'write noise functions', 'implement lighting models', or 'optimize draw calls'. The actions are more categorical than concrete.	3 / 5
Completeness	Has a clear 'what' (guide for writing GLSL shaders covering syntax, uniforms, effects) but completely lacks a 'when' clause. There is no 'Use when...' or equivalent trigger guidance, which per the rubric caps completeness at 3.	3 / 5
Trigger Term Quality	Includes relevant keywords like 'GLSL', 'shaders', 'Vertex', 'Fragment', 'uniforms', 'web', 'game engines'. However, it misses natural user phrases like 'shader code', 'GPU', 'WebGL', 'OpenGL', 'lighting', 'post-processing', '.glsl', '.vert', '.frag', or specific effect names users might ask about.	3 / 5
Distinctiveness Conflict Risk	GLSL shaders is a fairly specific niche that wouldn't easily conflict with most other skills. However, it could overlap with a general 'game development' or 'WebGL' skill. The mention of Vertex/Fragment shaders and uniforms helps distinguish it, but the broad 'web and game engines' phrasing introduces some overlap risk.	4 / 5
	Total	13 / 20 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
frontmatter_unknown_keys	Unknown frontmatter key(s) found; consider removing or moving to metadata	Warning

	Total	10 / 11 Passed

Repository: administrakt0r/AI-Agents-Safe-Coding-Skills
Path: skills/shader-programming-glsl/SKILL.md
Commit: 57c135b

Reviewed: 20 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.