Agent Skills are easy to discover and surprisingly difficult to evaluate. A community list may cover Claude Code, Codex, Cursor, and other tools, but the useful installation questions are usually buried in each project's own instructions: which agent is supported, what dependencies are required, what permissions are requested, and what output should be expected.
That makes a small compatibility matrix more useful than another long list. An independent developer can build one with AI agent development for the catalog workflow, a hosted HTML interface for filtering, and hosted Python for validation and tool calls. The important boundary is simple: the matrix records evidence and review status; it does not certify that an untested skill works.
What problem does the matrix solve?
The matrix solves the gap between discovery and a safe installation decision. A supplied community listing describes an "Awesome Fun Skills" collection aimed at Claude Code, Codex, and Cursor, with entries that change an agent's speaking style, interrogate a plan, or transform books, images, and websites into other formats. The same listing warns that dependencies, supported agents, permissions, and output effects can differ, and recommends reading each project's documentation and scripts before installing.
That warning is the real product requirement. A directory organized only by category answers "what exists?" It does not answer "can I use this in my current workflow?"
The first version should therefore treat every entry as a review record, not a recommendation. Useful fields include:
- Skill name and original project link, entered as user-supplied metadata.
- Supported agent names, such as Claude Code, Codex, or Cursor.
- Required dependencies, including a clear `unknown` value when the listing does not establish them.
- Requested permissions, such as file access or external-service access, with `unverified` where no review has been completed.
- Expected output, expressed as the author's description rather than a promise of quality.
- Evidence notes, review date, reviewer, and verification status.
- Compatibility conditions, such as a required browser, image tool, or external service.
The matrix should never convert an attractive example into a guaranteed result. A skill that is described as producing a poster, chart, animation, or video remains an unverified behavior until someone reviews its instructions and tests it in a defined environment.
How should each skill be represented?
Each skill should be stored as a small, explicit record with separate claims rather than one paragraph of marketing text. This makes filtering possible and makes uncertainty visible.
A practical record can use these values:
name: site-to-map
agents: [unverified unless documented]
dependencies: [browser, external service, or unknown]
permissions: [review required]
expected_output: 3D map, according to the supplied description
verification: unverified
notes: inspect the project's instructions and scripts before installationThe exact example above is illustrative, not a claim that the skill has been tested. In the source material, `site-to-map` is described as turning a personal website or navigation site into a paper-folding-style 3D map. The catalog should preserve that description while separating it from verified compatibility.
Use controlled values where possible. `agent` can be a list; `dependency` can be a list of names plus a confidence field; `permission` can distinguish file access, browser access, image tools, or external services; and `output` can describe the artifact or interaction expected. When the evidence is incomplete, use `unknown` or `unverified`, not a guessed value.
This structure also handles the more operational example in the market evidence. One developer built a VS Code extension called Berth to track Agent sessions in tmux. The post lists Claude Code, Codex, Gemini CLI, OpenCode, Copilot CLI, Cursor CLI, and Kimi CLI, while also stating that tmux 3.0 or newer is required, macOS and Linux are supported, and Windows requires WSL. Those are the kinds of compatibility details a useful matrix should expose. They are not evidence that every listed tool behaves identically.
How can VicroCode implement it?
VicroCode can support a reviewable web catalog using an HTML interface, Python validation, file storage, and a small database. Start with a deliberately narrow workflow:
- An operator uploads or pastes a skill record into a project file.
- An AI coding assistant generates the form, table, filters, and validation rules.
- A SQLite database stores normalized records and review states.
- Hosted Python checks required fields, normalizes agent names, flags contradictory values, and prepares tool-call payloads where an approved endpoint is available.
- The project is published as a hosted HTML application for browsing and sharing.
The browser interface can filter by agent, dependency, permission, output type, and verification status. A prominent `unverified` filter is more important than a visual badge claiming compatibility. A detail view should show the original description, the evidence note, the last review date, and the exact fields that still need inspection.
The hosted HTML interface can be built and tested with run HTML online. The Python side can handle schema validation, CSV or JSON import, duplicate detection, and controlled status transitions with run Python online. SQLite is enough for the first catalog; a LanceDB knowledge base could be considered later if the team needs semantic search across longer skill instructions, but that would not replace explicit structured fields.
If the project uses Model Center APIs or in-platform tool calls, keep their role narrow: summarize supplied documentation, suggest missing fields, or route a record through a validation step. Do not describe a model-generated summary as independent verification. API Endpoint Hosting may expose a controlled validation endpoint, but the matrix should record what was checked and with which input.
What should validation actually verify?
Validation should verify completeness and consistency, not promise that a third-party skill works. A useful first pass can check that every record has a name, source reference, agent field, dependency field, permission field, expected-output field, and status. It can also reject a record that says `verified` while its evidence note is empty.
The validator can flag these review conditions:
- An agent is named but no installation or support statement is attached.
- A dependency is mentioned without saying whether it is required or optional.
- A permission is inferred from an output description rather than documented.
- An output is copied as a guaranteed result instead of an expected result.
- The same skill appears under different names.
- A record claims support for an integration outside the reviewed evidence.
This is where the tool should be conservative. The supplied material mentions browser access, image tools, and external services as possible dependencies, but it does not establish a universal integration contract. The matrix should therefore allow those dependencies as review fields while marking unsupported or untested integrations as `unverified`.
The same rule applies to performance claims. Another market post reports benchmark figures for a Go-based networking project, including a 7800X3D test environment, 8 CPUs, 5,000,000 successful requests, 631,548 TPS, and 467.95M of average memory. Those figures belong to that project's stated benchmark context; they are not a reason to add performance guarantees to an Agent Skills catalog.
Where should the tool stop?
The tool should stop at documented compatibility and reproducible review. It should not install arbitrary skills, inspect private accounts, claim support for an agent that was not documented, or imply that a generated output will match a community example.
VicroCode's confirmed scope supports AI coding assistants and agent development, online HTML hosting and publishing, online Python execution, available Model Center APIs, API Endpoint Hosting, file management, SQLite, LanceDB, and project sharing or monetization. That is enough for the catalog, review workflow, validation service, and hosted interface described here.
It does not establish support for every external agent, browser automation system, image generator, cloud service, framework, deployment method, or third-party integration mentioned in a skill's documentation. Those items should appear as declared requirements or open review questions. If a user wants to add an integration outside the confirmed capabilities, the matrix should say that support is unverified rather than quietly presenting it as available.
Why is this useful for a small team?
The value is decision quality, not the size of the directory. A small team can turn a changing community list into a shared installation checklist, review a few high-interest skills, and publish the evidence without pretending to have tested everything.
That approach matches the broader pattern in the supplied evidence. Developers are switching among agents because different tasks or limits make one more suitable than another. They are also using AI coding workflows to deliver focused tools, from session dashboards to pipeline simulators and manufacturing design systems. The common operational need is not another claim that AI can do everything; it is a clearer way to define the boundary of the next task.
For the matrix, that means starting with perhaps a dozen manually reviewed entries rather than importing every listing. Test the schema, filter behavior, and review process first. Add records only when the operator can preserve the source description and state what remains unknown. Any customer adoption, installation success rate, or performance improvement from this tool is unverified unless measured separately.
FAQ
Is the matrix an installation marketplace?
No. It is a review and filtering tool that records documented requirements and unresolved risks; installation behavior remains outside its claims unless separately tested.
Can it prove that a skill works with an agent?
No. It can store documentation, test controlled validation rules, and show verification status, but a community description alone is not proof of runtime compatibility.
What is the safest first release?
The safest first release is a hosted HTML table backed by SQLite, with Python validation and an explicit `unverified` state for missing dependencies, permissions, integrations, and outputs.