Introducing Cyrus skills: customize how your Cyrus works

Every company runs on knowhow that lives in people's heads, Slack threads, emails, Notion pages - how you review code, ship deploys, triage bugs, QA design. Skills are how you make that knowhow legible to your Cyrus.

• Curated skills: a curated set of high-quality skills across Development, DevOps, Security, Design, and more. One click to install.
• Custom skills: capture your team's playbooks. Review checklists, deploy runbooks, triage flows. Your Cyrus uses them like any built-in capability.
• The right skills, every time: scope any skill to specific repos, Linear teams, or labels, so each session loads only what's relevant.

Once a skill exists, it stops being tribal knowledge. It's something your agent reads on every session that calls for it, and applies the way your team would.

Skills, not procedures

The previous version of Cyrus walked through rigid procedure sequences. Fixed steps in a fixed order. That was a fine starting point and a poor ceiling. Real work doesn't fit a single procedure, and real teams have dozens of overlapping playbooks.

In v0.2.41 we replaced procedures with skills. Skills are discovered at runtime: when Cyrus picks up a ticket, the model looks at the work, looks at the skills available for that context, and decides which to follow. More natural sessions. Fewer dead ends. And, most importantly, a clean place to put your team's knowhow so the agent actually uses it.

You don't have to think about which skill to invoke. Cyrus picks the right one based on the task, the repo, and the labels on the issue.

The curated skills library

Open the Skills page in your Cyrus dashboard. You'll find a curated, hand-picked set of high-quality skills across categories like:

• Development. Implementation flows, debugging, testing, refactoring.
• DevOps. Deploy runbooks, infra checks, release flows.
• Security. Dependency patching, audit checklists, vulnerability triage.
• Design. Design QA, accessibility passes, visual review.

Each card shows what the skill does, who maintains it, and a single Install button. Click install, and the skill is live for your Cyrus on the next session. No config files. No PRs. No restarting anything.

That's the whole loop:

1. Open the Skills page.
2. Find a skill you want.
3. Click install.
4. Your next Cyrus session knows how to do it.

Custom skills: your team's playbooks, captured

The curated library is the floor. The ceiling is the institutional knowledge your team already runs on every day, and rarely writes down.

Think about the playbooks living in your company right now:

• The PR review checklist your tech lead carries in their head: error handling at the boundary, reversible migrations, integration tests run before approving.
• The deploy runbook that's mostly a recurring Slack message: "page oncall, post to #releases, watch the smoke-test dashboard for ten minutes, then tag."
• The bug triage flow that one specific support engineer has been refining for two years.
• The design QA pass with the exact breakpoints and the exact Figma cross-checks the design team always asks for.

Custom skills are how you capture those playbooks once, in a form your Cyrus can read, and never have to re-explain.

Authoring a custom skill happens entirely in the dashboard, no files, no command line.

1. Open your Skills page and click New skill.
2. Give it a name and a one-line description. The description is what Cyrus reads to decide whether the skill is relevant for the work in front of it, so write it plainly: "Use when reviewing changes to the web frontend."
3. Paste the body of the skill into the editor. It's just markdown. The same checklist you'd send a new engineer on day one, written as a numbered list, with any constraints or breakpoints called out. For example:

# Frontend review

When reviewing a frontend PR:

1. Pull the PR locally and run `pnpm dev`.
2. Open the affected pages in the browser at the breakpoints below.
3. Check tab order and aria-labels on every new interactive element.
4. Compare against the Figma reference linked in the issue.
5. Only approve once items 1 through 4 pass; otherwise leave a comment
   with the specific failure.

## Breakpoints to check
- 375px (mobile)
- 768px (tablet)
- 1280px (desktop)

## Constraints
- Never approve without running the dev server.
- Never approve if any interactive element lacks an accessible name.

4. Set the scope in the same form. Pick the repositories, Linear teams, and labels this skill should apply to. (More on scope below.) 5. Click Save.

That's it. The skill is live for your Cyrus on the next session that matches its scope. The whole team uses the same version. No git, no ~/.cyrus/skills folders, no redeploy.

The best skills are specific and opinionated. Instead of "review carefully," your team's review skill says "check error handling at the boundary, verify the migration is reversible, and don't approve without running the integration tests." That's the difference between an AI agent that can review your code and one that reviews your code the way your team does.

Scoped to fit: only the right skills in the room

Installing a skill doesn't mean it fires on every session. Skills shouldn't.

Every skill in Cyrus can be scoped: to specific repositories, Linear teams, or labels. Each session only loads the skills that match its context, and nothing more. Less noise for the agent. Sharper output for you.

A concrete example: imagine that frontend review skill above. You don't want it firing when Cyrus picks up a backend Linear ticket. There's nothing to review in the browser, and the breakpoint checklist would just be wasted context. So you scope it:

• Repo: acme/web
• Linear team: Frontend
• Labels: frontend, ui

Now the skill is only available when Cyrus is working on a ticket in the Frontend team that's labeled frontend or ui, on the acme/web repo. A backend session never sees it. A docs session never sees it. The skill is invisible until it's relevant, and razor-sharp when it is.

You set scope on the same Skills page, right next to the install button. Repo, team, or label. Pick any combination.

This is the part we're most excited about. Scope is what makes a growing skills library stay useful. As your team adds 5, 20, 50 skills, scope is what keeps each Cyrus session focused on the handful that actually matter for the work in front of it.

AI isn't bolted on

The companies getting the most out of AI right now aren't the ones with the cleverest prompts. They're the ones whose AI knows how they work: their review standards, their deploy steps, their triage logic, their definition of done. That's not a model problem. That's an integration-with-your-knowhow problem.

Curated skills give you a strong default. Custom skills capture the playbooks your team already runs. Scope keeps every session focused on only what matters for the work in front of it.

AI isn't something you bolt onto the side of a company. With skills, your company's knowhow becomes the way your Cyrus works.

Open your Skills page, install one from the curated library, and write your first custom skill. The next ticket Cyrus picks up will know how your team ships.