Installing Skills Like Installing Packages

Debugging sessions start from scratch instead of following a loop you already know works.

Skills fix this by encoding workflows as instructions the agent follows automatically. But until now, getting skills into Elyra meant either installing an extension that bundled them, or hand-rolling SKILL.md files in .elyra/skills/.

v0.7.3 adds a third option: install community skills from a registry with one command.

The registry

The Elyra Skills Registry lives at github.com/kwhorne/elyra-skills. It's a collection of standalone, vendor-neutral skills that work in Elyra, Claude Code, and any other agent that follows the Agent Skills spec.

Eight skills ship in the initial registry:

Skill What it teaches the agent code-review Structured review with severity tags: blocker, major, minor, nit conventional-commits Generate Conventional Commits messages from staged changes debugging Systematic loop: reproduce, isolate, fix, verify, prevent regression pr-description Write clear PR descriptions from a diff refactoring Characterization tests first, small reversible steps, verify after each test-writing Decide what to test, arrange/act/assert structure, avoid common pitfalls api-design Consistent REST endpoints: naming, status codes, pagination, errors security-audit OWASP-flavored review: input handling, auth, secrets, dependencies

These aren't framework-specific. They work on any codebase, any language, any stack. Framework-specific knowledge — Laravel, Vue, React — lives in Elyra extensions where it ships pre-installed.

Installing skills

/skills install code-review

That's it. Elyra fetches the skill from the registry and installs it to ~/.elyra/agent/skills/code-review/. The skill is available in every project from that point on.

Install several at once:

/skills install code-review debugging conventional-commits

Three skills, one command. Elyra fetches the registry manifest, downloads each skill's files (SKILL.md, scripts, references), and reports what landed:

Installed: code-review → ~/.elyra/agent/skills/code-review/ Perform a structured code review with severity-tagged feedback... debugging → ~/.elyra/agent/skills/debugging/ Systematically debug a problem: reproduce, isolate, fix, verify... conventional-commits → ~/.elyra/agent/skills/conventional-commits/ Generate Conventional Commits messages from staged changes...

Run /reload to load new skills, or restart the session.

After a /reload, the skills are active. The agent sees their descriptions in the system prompt and loads them automatically when your task matches.

What happens after installation

You don't invoke skills explicitly. They're passive. The agent loads them when the task matches the description.

After installing code-review, just ask:

Review the changes in src/payments/ before I merge

The agent sees that this matches the code-review skill's description ("Use when the user asks for a code review, PR feedback, or wants to evaluate a diff before merge"), loads the full instructions, and follows the structured review process — severity tags, specific file references, actionable feedback.

After installing debugging:

The checkout flow silently fails for orders over $1000

The agent follows the debugging skill's systematic approach: reproduce the issue, isolate the root cause, implement the fix, verify it works, and add a regression test. Instead of jumping straight to a guess, it follows a loop that's been proven to work.

After installing conventional-commits:

Write a commit message for the staged changes

The agent runs git diff --staged, analyzes the changes, and produces a properly formatted Conventional Commits message with the right type, scope, and description. The conventional-commits skill even ships with a scripts/suggest.sh helper that the agent can execute for additional analysis.

Checking what's installed

/skills

Lists every loaded skill with its name, description, script and reference counts, and where it came from — registry install, extension, or local project.

Skills (11) code-review Perform a structured code review with severity-tagged feedback... local debugging Systematically debug a problem: reproduce, isolate, fix, verify... local elyra-swarm Multi-agent swarm orchestration... 1 reference(s) · extension

elyra-docker Docker container awareness... extension

Where skills live after installation

Registry skills install to /.elyra/agent/skills/<name>/. That's your global skills directory — available in every project.

If you want a skill only in one project, copy it to .elyra/skills/<name>/ and commit it to git. Project-local skills take priority over global ones if names conflict.

/.elyra/agent/skills/     # global, every project
.elyra/skills/             # project-local, committed to git

Skills from extensions (swarm, docker, subagents) load automatically when the extension is installed. They don't show up in the skills directory — they're bundled with the extension itself.

Skills with scripts

Some skills include executable scripts in a scripts/ directory. The conventional-commits skill, for example, ships with scripts/suggest.sh that analyzes a git diff and suggests a commit type.

Scripts aren't auto-executed. The agent can choose to run them via the bash tool, subject to the same approval rules as any other command. The skill's instructions tell the agent when and how to use them.

This is the key advantage of scripts over natural language: a validation check written in bash is deterministic. It either passes or fails. The agent doesn't need to interpret whether the validation succeeded — the exit code tells it.

Skills with references

Skills can include a references/ directory with longer documentation that the agent reads on demand. The security-audit skill might include a references/owasp-top-10.md with detailed descriptions of each vulnerability class.

References are the third level of progressive disclosure:

Frontmatter (always in context): name and description, ~50 tokens
SKILL.md body (loaded when task matches): full instructions, ~500 tokens
References (loaded when needed): deep documentation, loaded individually

This keeps token usage low even with many skills installed.

The open standard

Every skill in the registry follows the Agent Skills specification. They're not Elyra-specific. If you use Claude Code, you can copy the skill folder into your Claude Code skills directory and it works identically.

The same applies in reverse. Skills built for Claude Code work in Elyra. The format is the same: a folder with a SKILL.md containing YAML frontmatter and markdown instructions.

This matters for the community. A skill contributed to the Elyra registry is a skill that works everywhere. The value compounds across every compatible agent, not just one.

Contributing

The registry accepts community contributions. One skill per PR, standalone and generic, with a description that includes trigger phrases. The full guide is at github.com/kwhorne/elyra-skills/CONTRIBUTING.md.

Good first contributions: accessibility-review, performance-budget, dependency-update, migration-safety, documentation-writing. Workflows that every developer does but nobody has standardized for AI agents yet.