import-skill
Import a Rome skill from a URL, a pasted SKILL.md, or a plain-language description — validate it against Rome's frontmatter parser, preview the final file, and install it into the user-skills carrier app after the guardian confirms.
rome-os · AI review on file
Installation
Read the source and dependencies before running a command. Copying does not install or execute anything.
npx skills add rome-os/rome --skill import-skillAbout this skill
name: import-skill description: Import a Rome skill from a URL, a pasted SKILL.md, or a plain-language description — validate it against Rome's frontmatter parser, preview the final file, and install it into the user-skills carrier app after the guardian confirms. tools: [Read, Write, Edit, Bash, Glob, Grep, WebFetch]
Import a skill
Turn what the guardian brings you into something installed — a URL to an existing skill, a pasted SKILL.md, or a description of one they wish existed. Brainstorm with them: propose, listen, revise. Don't install anything without getting a clear go-ahead.
Most of what you're handed is a plain skill for the user-skills carrier. The involved ones — a setup step, real interaction, a multi-step process — are better off as their own app. Sorting which is which, with the guardian, is part of the job: see "Skill, or a dedicated app?" before you install.
Classify the input
- URL → see "Resolving a URL".
- Pasted SKILL.md (frontmatter + body, or close to it) → validate, preview.
- Description (prose, a wish, a workflow explained) → see "Generating".
- Empty or ambiguous → ask one short question. Don't guess.
Resolving a URL
github.com/<owner>/<repo>/blob/<ref>/<path>→ fetch the raw formhttps://raw.githubusercontent.com/<owner>/<repo>/<ref>/<path>.github.com/<owner>/<repo>/tree/<ref>/<dir>→ list it viahttps://api.github.com/repos/<owner>/<repo>/contents/<dir>?ref=<ref>and download the SKILL.md plus its auxiliary files.- Bare repo → look for
SKILL.mdat the root, then underskills/. - Anything else → fetch it; if it's skill-shaped, proceed; if it's prose describing a workflow, offer to generate a skill from it.
If the source holds more than one skill (several SKILL.md under skills/, a
repo of them, a page linking many), don't pick for the guardian: list each one
you found — path, name, and description — and ask which to import. They may
choose one, some, or all; import each as its own pass through the rest of this
flow (validate → preview → install), so every skill gets its own confirmation.
On a network error or 404, say so and ask for a corrected link.
Generating from a description
The guardian is the domain expert; you're the author. Ask at most 2–3 focused questions, only where the description is genuinely open:
- Trigger — when should an agent reach for this? (Becomes the description line, which is also the search index.)
- Procedure — the concrete steps, commands, decision points. "Check the logs" isn't an instruction; "run X and look for Y" is.
- Tools — which built-ins the steps need.
- Boundaries — what it should refuse or hand off.
Draft the SKILL.md yourself and preview it. The body is second-person, imperative, concrete — instructions for a future agent, not human docs.
Skill, or a dedicated app? Decide before you install
A skill is pure instructions an agent reads. Some requests are apps wearing a SKILL.md, and the carrier gives them a worse version of what they asked for. Once you understand the request, judge it. App-shaped signals — any one means it wants to be its own app:
- an init / setup step before it's usable (credentials, first-run config);
- it needs to interact — ask and react, not just run top-to-bottom;
- a real multi-step process, its own data / operations / UI, or background / scheduled execution.
A shell command or two inside otherwise-pure instructions is still a skill. When the signals are real, put the choice to the guardian — don't pick for them:
- Import as a skill → the user-skills carrier (the flow below).
- Build a dedicated app → a brand-new app of its own, friendly and interactive.
Only continue into validate/preview/install when they choose the skill.
Building a dedicated app
Read the coding:app_creation skill with read_skill and follow it to scaffold,
build, and install a brand-new app — its OWN app id, never user-skills or
the carrier. Carry what you've learned from the guardian as the brief: what the
thing does, its init/setup step, the interactions it needs.
Design a friendly flow: an init step that gets the guardian set up, interaction
that guides rather than dumps questions, and — where it fits — a conversational
agent they talk to, with the app's entry dropping straight into that chat.
(A pure inputs → steps → result automation isn't an app — coding:app_creation will
redirect it to coding:workflow_creation, as it should.)
Validate against Rome's parser
Rome parses frontmatter with regexes, not YAML. A violating skill installs but is silently dropped from the catalog. Enforce on every skill:
- Starts with a
---line and has a closing---. name:is a single lowercase kebab-case line matching the install folder.description:is a single line — collapse folded (>) or multi-line ones.tools:is only read inline (tools: [A, B, C]) — convert dash-lists; drop one you can't convert and say so.- Other keys are ignored, harmless — keep them.
Auto-fix 2–4 and note each fix in the preview. Then check list_skills for a
name collision (propose an alternative rather than shadow), and make sure the
description carries the trigger words someone would search — search_skills
matches name/description/tools, never the body.
Preview, then confirm
Show the guardian the complete final SKILL.md in a fenced block (and any
auxiliary files), a note of every fix you made, and the install path
user-skills/skills/<name>/. Ask, and wait. Anything short of a clear yes is
feedback — revise and preview again.
Install into the carrier
Skills install into one carrier app, user-skills, at
<custom app authoring directory from your Runtime Context>/user-skills
(~/.rome/<profile>/projects/apps/user-skills).
If it doesn't exist, create it — a minimal hand-rolled layout, no build
toolchain, so the coding:app_creation scaffold doesn't apply. It