Name: ax-go-agent-memory-skills
Rating: 64 (1 reviews)
Author: ax-llm

ax-go-agent-memory-skills

Use when writing Go code with `github.com/ax-llm/ax/packages/go` for agent memory, recall callbacks, dynamic skill discovery, loaded-skill state, and used-skill tracking.

Quality

76%

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 ./packages/go/skills/ax-go-agent-memory-skills/SKILL.md

Quality

Content

72%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 body is a lean, well-structured overview that points cleanly to the package's own docs and examples with no padding. Its weaknesses are actionability and workflow clarity: most content describes runtime behavior rather than giving executable steps, and an `ax`/`axllm` qualifier inconsistency plus the absence of any validation/verification guidance leaves execution ambiguous.

Suggestions

Reconcile the package qualifier so Core Pattern and Relevant API Surface agree (use either `ax.` or `axllm.` consistently) so a reader can copy code without guessing the import.

Add one or two more concrete code snippets for the highest-value tasks (e.g., registering an `onUsedSkills` observer, or calling `ExportRuntimeState`/`RestoreRuntimeState`) so the guidance is mostly executable rather than descriptive.

Add a short verification step for the state-restore guidance (e.g., 'round-trip Export then Restore and confirm loaded skills reapply') since state snapshots are a failure-prone, batch-like operation where a validation checkpoint would raise workflow clarity.

Dimension	Reasoning	Score
Conciseness	The body is dense and information-packed ("Constructor `skills` seed the loaded-skill prompt without firing load observers"), assumes Claude's competence with no basic-concept padding, and every line carries specific API behavior, matching the lean-and-efficient top anchor.	5 / 5
Actionability	It gives one executable snippet (`ax.NewAgent(...)` / `helper.Forward(...)`) and concrete example file paths, but most guidance describes behavior rather than giving runnable code, and the `ax.` vs `axllm.` package-qualifier inconsistency between Core Pattern and Relevant API Surface leaves a key detail ambiguous, matching the some-guidance-but-incomplete anchor.	3 / 5
Workflow Clarity	Guardrails imply a rough order ("Start from package examples for exact native syntax before inventing a new call shape") but there is no sequenced multi-step workflow or validation checkpoint; since this is a multi-capability reference skill rather than a single-task one, the simple-skill exception does not lift it above 3.	3 / 5
Progressive Disclosure	No bundle files exist, and the body (~50 lines) is well-organized with clearly signaled one-level-deep references to package materials ("Package API docs: `API.md` and `axir-api.json`", "Runnable examples: `examples/`"), with no nested references, matching the clear-overview top anchor.	5 / 5
	Total	16 / 20 Passed

Description

80%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.

The description is strong: it pairs an explicit 'Use when' trigger with a specific package path and a comprehensive list of capabilities, giving clear what-and-when guidance with low conflict risk. Its weakest point is trigger-term quality, since most capability terms are package jargon rather than natural user phrasing.

Suggestions

Add natural-language synonyms alongside the jargon (e.g., 'agent memory (recalling prior turns)' or 'skill lookup') so users who phrase needs casually still match the trigger.

Soften or gloss technical terms like 'recall callbacks' and 'loaded-skill state' with a plain phrase so the trigger terms read as things a user would actually say.

Dimension	Reasoning	Score
Specificity	Quotes "writing Go code with `github.com/ax-llm/ax/packages/go` for agent memory, recall callbacks, dynamic skill discovery, loaded-skill state, and used-skill tracking" lists several specific capability areas, but they are domains rather than concrete actions, so it sits just below the comprehensive 5 anchor.	4 / 5
Completeness	"Use when writing Go code with [package] for [five capabilities]" explicitly answers both what it does and when to use it with a concrete trigger phrase, matching the top anchor.	5 / 5
Trigger Term Quality	"writing Go code" and "agent memory" are natural user phrases, but "recall callbacks," "dynamic skill discovery," "loaded-skill state," and "used-skill tracking" are package-specific jargon with no common synonyms or variations, matching the some-keywords-but-missing anchor.	3 / 5
Distinctiveness Conflict Risk	The fully-qualified package path `github.com/ax-llm/ax/packages/go` plus the narrow memory/skill capability set carve a clear niche with minimal conflict risk against other skills.	5 / 5
	Total	17 / 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: packages/go/skills/ax-go-agent-memory-skills/SKILL.md
Commit: dec4f9e

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