There's a moment every developer has with a coding agent. You ask it to review a pull request, and it responds with a wall of well-meaning fluff — "Great use of variables!" — while quietly missing the SQL injection on line 42. The agent isn't dumb. It just doesn't know how you want the job done.

That's the problem Skills solve.

The why: knowledge on demand, not knowledge on blast

The obvious fix is to stuff more instructions into the system prompt. Review code like this. Write commits like that. Always check for X, never do Y. It works — briefly. Then your prompt is three thousand words long, the agent forgets half of it, and every conversation starts with the cognitive equivalent of reading the terms and conditions.

Skills flip the model. A skill is a small Markdown file with a bit of frontmatter on top. The frontmatter tells the agent when the skill is relevant. The body tells it what to do. The agent reads the catalog of descriptions — cheap, a sentence each — and only loads the full skill when your task actually matches.

Ask for a code review, and the code-review skill wakes up. Ask about dinner recipes, and it stays politely asleep.

It's the difference between a colleague who knows everything all the time (exhausting, doesn't exist) and one who knows exactly which book to pull off the shelf (delightful, hireable).

The anatomy: it's just Markdown

Here's the honest part: there is no magic. A skill looks like this:

---
name: code-review
description: Perform a structured code review with severity-tagged
  feedback. Use when the user asks for a code review, PR feedback,
  or wants a second opinion on a change.
allowed-tools: read, bash, grep
---
¶Code Review
Reviews code with actionable, severity-tagged feedback.
No vibes, no rubber-stamping.
¶Procedure

Establish scope. A diff, a file, a directory, or a PR?
Read the code in context. Open imports, callers, and tests.
Group findings by severity — blocker, major, minor, nit.
Stop when done. Don't pad the report.

That's a real excerpt. Plain Markdown, readable by humans, reviewable in a pull request, diffable in git. If you can write a README, you can write a skill. And because skills follow the open Agent Skills spec, the same file works in Elyra, Claude Code, and any other compatible agent. No lock-in, no proprietary format, no SDK to learn.

The how: thirty seconds to a better agent

Inside Elyra, installing a skill is one slash command:

/skills install code-review

Want a starter pack? Stack them up:

/skills install code-review debugging conventional-commits

The skills land in ~/.elyra/agent/skills/ and are available in every project from that moment on. Run /skills to see what's installed.

Three skills, three small stories

conventional-commits — You've staged your changes, and instead of typing git commit -m "fix stuff" for the eleventh time today, you ask the agent for a commit message. The skill reads the staged diff and produces a proper fix(auth): prevent session fixation on login — scope, type, and a body that explains the why. Your future self, doing archaeology in git log six months from now, sends quiet thanks.

debugging — Something's broken and you don't know why. Without guidance, agents love to guess: change a line, hope, repeat. The debugging skill enforces discipline — reproduce first, isolate, fix, verify, then add a regression test. It turns the agent from a hopeful tinkerer into the methodical senior engineer who's seen this kind of bug before.

refactoring — The scariest phrase in software is "I'll just clean this up real quick." This skill insists on characterization tests before touching anything, then moves in small, reversible steps with verification after each one. Boring? Wonderfully so. Boring is how refactors land without taking production down with them.

A community pool, not a walled garden

All of this lives in the open at github.com/kwhorne/elyra-skills — currently 26 skills covering everything from security-audit and accessibility-review to incident-response and database-migration. Every skill is plain Markdown, reviewed before merge, MIT-licensed, and versioned together.

You can browse the whole catalog right here at elyracode.com/skills — searchable, taggable, and synced automatically from the repository. When a skill is merged on GitHub, it shows up on the site seconds later.

And if you've developed a workflow worth sharing — the way you write changelogs, the way your team handles releases — wrap it in frontmatter and open a pull request. Someone out there is about to ask their agent to do exactly that thing, and your skill is the difference between a shrug and a great answer.

The short version

• Skills are Markdown workflows your agent loads only when the task matches.

• They keep your system prompt lean while making the agent dramatically better at specific jobs.

• They're portable — one open spec, many agents.

• Install in seconds: /skills install <name>.

• Browse them all: elyracode.com/skills.

Your agent is already smart. Skills are how it gets wise.