Name: ax-go-flow
Rating: 61.6 (1 reviews)
Author: ax-llm

ax-go-flow

Use when writing Go code with `github.com/ax-llm/ax/packages/go` for flows, nodes, program graphs, nested programs, dynamic options, caching, and optimizer components.

Quality

77%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide

Securityby

Low

Low-risk findings worth noting

Fix and improve this skill with Tessl

tessl review fix ./website/static/go/.well-known/agent-skills/ax-go-flow/SKILL.md

Quality

Content

57%Weight 40%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 flow-pattern half of the body is excellent: lean, concrete, executable Go examples ordered from simple to advanced. The body is dragged down by the 'Astra Session Work' wall of dense prose that belongs in a one-level-deep reference file, references to bundle files that are not actually present, and a lack of explicit validation checkpoints (plus an axllm.NewFlow vs ax.NewFlow naming inconsistency).

Suggestions

Move the 'Astra Session Work' spec material into a separate reference file (e.g., references/astra-sessions.md) and keep only a short pointer plus the Go-specific essentials in SKILL.md, which would improve both conciseness and progressive disclosure.

Add an explicit validation checkpoint to the workflow (e.g., 'After composing a flow, verify it with the no-key scripted transport examples under examples/ before using provider credentials') so the sequence has a verify-then-proceed loop.

Fix the naming inconsistency between 'Relevant API Surface' (`axllm.NewFlow`) and the code examples (`ax.NewFlow`), and define or annotate the placeholder programs (research, audience, join, critique, revise) used in the fan-out and refine snippets so they are self-contained; also ensure referenced files (API.md, examples/) are actually shipped in the bundle.

Dimension	Reasoning	Score
Conciseness	The core pattern sections are lean and code-heavy, but the 'Astra Session Work' section is ~28 lines of dense paragraph prose covering sessions, MCP policy, child agents, cancellation, WebSocket adapters, and validators — content that could be tightened substantially. It stays above anchor 2 because it explains genuinely domain-specific behavior rather than concepts Claude already knows, but below anchor 4 because the verbosity exceeds 'minor instances of over-explanation'.	3 / 5
Actionability	Provides concrete, near-executable Go snippets (NewFlow/Execute/Returns chains, StreamingForward range loop, cachingFunction option) covering the common cases. Below anchor 5 because later snippets reference undefined programs (research, audience, join, critique, revise) and 'Relevant API Surface' says `axllm.NewFlow` while every code example uses `ax.NewFlow`; above anchor 3 because the code is real and executable, not pseudocode.	4 / 5
Workflow Clarity	The patterns progress clearly from core flow to typed programs, branching, fan-out/join, refinement, and run/stream/cache variants, but validation checkpoints are only implicit — the Guardrails mention 'no-key examples for deterministic local checks' with no explicit verify-then-proceed step or error-recovery loop. This matches anchor 3 (sequence present, checkpoints missing or implicit) rather than anchor 4's 'most checkpoints present'.	3 / 5
Progressive Disclosure	Sections are well organized with clearly signaled references ('API.md', 'axir-api.json', 'axir-capabilities.json', 'examples/', an external gallery URL), but none of those files exist in the bundle (no references/, scripts/, or assets/ directories), and the spec-length 'Astra Session Work' material is inlined where it belongs in a separate reference file. Structure and signaling keep it above anchor 2; the missing bundle files and inlined spec content keep it below anchor 4.	3 / 5
	Total	13 / 20 Passed

Description

87%Weight 40%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.

A strong description: it combines an explicit 'Use when' trigger with a precise package identity and an enumerated list of subsystems, in third person and without padding. The only shortcoming is modest trigger synonym coverage (e.g., 'workflow', 'streaming', 'agent') beyond the listed terms.

Dimension	Reasoning	Score
Specificity	Names the concrete package ('writing Go code with `github.com/ax-llm/ax/packages/go`') and enumerates specific subsystems ('flows, nodes, program graphs, nested programs, dynamic options, caching, and optimizer components') — several specific actions with minor gaps in coverage (streaming, examples, session work not mentioned). It lists more than 1-2 concrete actions (above anchor 3) but is a topical listing rather than comprehensive concrete actions (below anchor 5).	4 / 5
Completeness	Explicitly answers both: what ('writing Go code with `github.com/ax-llm/ax/packages/go` for flows, nodes, program graphs...') and when ('Use when writing Go code...') with concrete trigger phrases. Both are explicit and specific, matching the anchor-5 example structure rather than the anchor-4 case where the 'when' could be more explicit.	5 / 5
Trigger Term Quality	Includes natural terms users of this package would say — 'Go code', 'flows', 'nodes', 'caching' — plus the exact import path. Missing common synonyms and variations ('workflow', 'AxFlow', 'streaming', 'agent'), so not comprehensive coverage (anchor 5), but better than 'some relevant keywords' with missing phrases (anchor 3).	4 / 5
Distinctiveness Conflict Risk	Scoped to a single named Go package (`github.com/ax-llm/ax/packages/go`) with distinctive subsystem terms (program graphs, nested programs, optimizer components) — a clear niche with distinct triggers and minimal conflict risk with other skills.	5 / 5
	Total	18 / 20 Passed

Validation

93%

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 — 15 / 16 Passed

Validation for skill structure

Criteria	Description	Result
frontmatter_unknown_keys	Unknown frontmatter key(s) found; consider removing or moving to metadata	Warning

	Total	15 / 16 Passed

Repository: ax-llm/ax
Path: website/static/go/.well-known/agent-skills/ax-go-flow/SKILL.md
Commit: 3f630a0

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