Skills - Resolve AI

Skills are the way you teach Resolve a specific capability — a triage flow, a rollback procedure, a postmortem template, a standard report. Each skill is a small, self-contained set of instructions that Resolve loads on demand when the task calls for it. Skills follow the open Agent Skills standard, the same format used by Claude and a growing list of agentic tools. A skill you’ve already written for another agent will work in Resolve, and a skill you write in Resolve travels with you.

Why Skills?

Resolve already reads your Team Knowledge — your Resolve.md, runbooks, and docs — to understand your environment. That works well for interpretive knowledge: conventions, glossaries, system overviews, things the agent should reason about. What knowledge-as-prose handles less reliably are procedures: the exact rollback sequence with the right flags, the five-query triage flow your senior on-call runs on every payments alert, the postmortem template you’ve spent a year refining. When procedures live as prose, the agent has to interpret them, and interpretation drifts — a paraphrased step here, a flag re-derived there. Skills package the procedural parts of your operations so the agent invokes them directly instead of paraphrasing them out of prose. A wiki page about your canary rollback tells the agent what to do. A skill is the rollback. Skills are especially useful when:

A task is performed frequently
The investigation steps are well-defined
The output should be consistent across runs
The action depends on team-specific tooling, dashboards, or conventions

How Skills work

Resolve loads skills using progressive disclosure, so you can register many skills without bloating the agent’s context:

Discovery. Resolve loads only the name and description of every available skill at the start of a task — just enough to know when each might be relevant.
Activation. When a task matches a skill’s description, Resolve pulls the full instructions into context.
Execution. Resolve follows the instructions in the skill body.

This applies everywhere Resolve reasons about your systems:

Alert investigations automatically pick up skills whose descriptions match the alert.
The Assistant (chats and tasks) picks up skills whose descriptions match the user’s request.
Slash commands let users invoke a skill directly by name (see Slash Commands below).

What a skill looks like

A skill is a Markdown file with YAML frontmatter. The minimum is a name and a description:

---
name: payments-db-connection-pool
description: Use when investigating latency or error-rate spikes on the
  payments-api service, especially when the alert references database
  wait times or 5xx errors from /charge or /refund endpoints.
---

The payments-api service runs on a shared connection pool with 50 max
connections. Sustained db_pool_active above 90% for 60+ seconds causes
request queueing and downstream 5xx errors before the database itself
shows distress.

When investigating latency on payments-api, check db_pool_active first —
it leads the latency curve by ~30 seconds.

The pool size is intentionally tight to push backpressure upstream
rather than fan out load to the DB; do not recommend increasing pool
size as a fix without consulting the payments team.

The frontmatter is what Resolve sees during discovery. The body is loaded only when the skill activates.

Resolve currently supports SKILL.md only. The Agent Skills specification also allows skills to bundle scripts, reference files, and assets in adjacent directories. Resolve will load the SKILL.md body, but bundled scripts and file references aren’t executed or fetched yet. Support is on the roadmap — until then, keep all skill content inline in SKILL.md.

Frontmatter fields

Field	Required	Notes
`name`	Yes	1–64 characters. Lowercase letters, numbers, and hyphens only. No leading/trailing or consecutive hyphens.
`description`	Yes	Up to 1024 characters. Should describe what the skill does and when to use it. The clearer the trigger, the more reliably Resolve picks it up.

Resolve supports the optional fields defined in the Agent Skills specification (license, compatibility, metadata). Most skills don’t need them.

Creating skills in Resolve

Skills live on the Skills section in your team page (Teams > YourTeam). There are 3 ways to add them.

1. Start from a Resolve template

Click + Add > Import from template to pick from Resolve-provided templates such as deployment monitoring, common triage flows, postmortem generation, and more! This is the fastest way to get started and you can customize it for your environment.

2. Import from external sources

Click + Add > Import from GitHub to connect a Git source. Resolve auto-detects any folder following the open Agent Skills format and shows you the list — you can filter which skills to import, so the same repo can serve multiple agents. The latest version is fetched at activation time, so updating the source updates the skill in Resolve.

3. Write a skill from scratch

Click + Add > New Skill and write the SKILL.md content directly in the in-app editor. Useful when you’re encoding a procedure you’ve never written down before. Once a skill is in the system, it’s immediately available to alert investigations, chats for your team, and as a slash command — no further configuration required.

Slash Commands

Slash commands are how users invoke a skill directly, instead of leaving it to Resolve’s discretion. In any Assistant input — chat or task — type / to bring up an autocompleted list of available skills, then pick one. Slash commands are useful when you want a deterministic invocation: you know exactly which skill should run, and you don’t want the agent deciding for itself. Common patterns:

Standard reports — end-of-shift handoffs, weekly reliability summaries, deploy reports
Opinionated triage flows — the multi-step investigation your senior on-call runs from muscle memory
Templates — postmortems, status-page updates, incident summaries in your team’s voice
Focused lookups — service ownership, recent deploys, the right runbook for an alert

Any skill can be invoked as a slash command. The command name is the skill’s name field, and the prompt after the command is passed through as input.

Example: a `/triage-payments-latency` skill

An opinionated triage flow that encodes the order your senior on-call investigates a known alert class:

---
name: triage-payments-latency
description: Run the standard triage flow for latency alerts on the
  payments-api service. Use when investigating /charge or /refund p95
  latency spikes, payments-api SLO burn alerts, or when the user asks
  to triage payments latency.
---

Run these checks **in order** and stop as soon as you find the cause:

1. **DB connection pool** — check `db_pool_active` on the `payments-overview`
   Grafana dashboard. Sustained > 90% for 60+ seconds is the most common
   cause of payments latency and leads the latency curve by ~30 seconds.
2. **Recent deploys** — list payments-api deploys in the last 2 hours.
   Correlate deploy timestamps against the latency spike.
3. **Upstream dependencies** — check the auth-service and ledger-service
   dashboards for their own latency or error-rate elevation. Payments
   latency often inherits from upstream.
4. **Queue depth** — check `payments_outbox_lag` on the same dashboard.
   Sustained growth indicates a downstream consumer is behind.
5. **Logs** — only if 1–4 are clean, search payments-api error logs for
   the spike window.

### Output
- Lead with which step found the cause (or "no clear cause from steps 1–5").
- Include the specific metric value or log signature that confirmed it.
- Do not recommend increasing the connection pool size as a fix —
  the tight pool is intentional. Page the payments team instead.

Best practices

The full guidance lives at agentskills.io/skill-creation/best-practices. A few highlights worth keeping in mind for Resolve: Write descriptions that describe when to use the skill, not just what it does. The description is the only thing Resolve sees during discovery, so vague descriptions activate at the wrong times — or not at all. Include the keywords, alert names, services, or phrases that should trigger the skill. Keep skills focused. A skill that triages payments latency and generates a postmortem and runs a rollback is too broad. Split it. Skills compose well; over-stuffed skills don’t. Be specific about data sources and output format. “Check the dashboard” is weaker than “query the payments-overview Grafana dashboard, panel db_pool_active, and report the 5-minute average.” Specificity is what makes skills repeatable. Add what the agent wouldn’t know. Skip the explanations of HTTP, SQL, or your observability tool. Focus on the project-specific conventions, gotchas, and judgment calls only your team knows. Iterate from real use. When Resolve runs a skill and you correct it, fold the correction back into the skill. The skill heatmap on the Skills page shows how often each skill was invoked and for what alerts — use it to tune descriptions and catch skills that aren’t being picked up.

How Skills relate to other Knowledge

Skills sit alongside the rest of Teams & Knowledge. Each type plays a different role:

Knowledge Type	Best for
Resolve.md	General context, conventions, glossaries, system overviews — things the agent should reason about.
Alert Runbooks	Step-by-step guidance pulled in deterministically when a specific alert fires.
Dashboard Guidance	How to read and interpret a specific dashboard’s panels.
Docs	General reference material — architecture diagrams, design docs, on-call rotations.
Skills	Specific, repeatable procedures invoked dynamically based on the task — including everything that used to be a slash command.

Skills don’t replace your other knowledge. They give the procedural parts of your operations a format that lets them run exactly the same way every time. Alert runbooks can even reference skills directly: “For latency alerts on payments-api, invoke the payments-db-connection-pool skill before checking application logs.”

​Why Skills?

​How Skills work

​What a skill looks like

​Frontmatter fields

​Creating skills in Resolve

​1. Start from a Resolve template

​2. Import from external sources

​3. Write a skill from scratch

​Slash Commands

​Example: a /triage-payments-latency skill

​Best practices

​How Skills relate to other Knowledge

​Further reading

Why Skills?

How Skills work

What a skill looks like

Frontmatter fields

Creating skills in Resolve

1. Start from a Resolve template

2. Import from external sources

3. Write a skill from scratch

Slash Commands

Example: a `/triage-payments-latency` skill

Best practices

How Skills relate to other Knowledge

Further reading