New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Import Skill

by rome-os in rome-os/rome

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…

MITAuto-check passedWriting & Content

Install Import Skill

skills CLI
$ npx skills add rome-os/rome --skill import-skill -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install rome-os/rome import-skill --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/rome-os/rome.git skills-src && mkdir -p .claude/skills && cp -r skills-src/rome_apps/skills/src/skills/import-skill .claude/skills/import-skill && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
import-skill
GitHub stars
737
Token cost
~2.4k tokens
SKILL.md length
1,043 words
Files
1
Skills in repo
18
Repo updated
First seen
Licence
MIT

At a glance

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…

  • Works in 5 steps: Starts with a --- line and has a closing… → name: is a single lowercase kebab-case… → description: is a single line — collapse… → …
  • Tasks that involve Plain language and style rules
  • SKILL.md covers Classify the input, Resolving a URL, Generating from a description and Skill, or a dedicated app?…, plus 5 more sections
  • Calls git; reaches raw.githubusercontent.com and api.github.com

What it does

Import Skill is an agent skill from rome-os/rome. 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.

Its SKILL.md is about 2.4k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Writing & Content, covering Plain language and style rules. The repository describes itself as: A compounding agent OS for recursive agents. Also an open source alternative to Grok Bot and Meta's Muse. The licence is MIT.

When your agent uses it

  • Tasks that involve Plain language and style rules

Example prompts

  • “/import-skill”

Workflow steps

5 steps, taken from the first numbered list in SKILL.md.

  1. Starts with a --- line and has a closing ---.
  2. name: is a single lowercase kebab-case line matching the install folder.
  3. description: is a single line — collapse folded (>) or multi-line ones.
  4. tools: is only read inline (tools: [A, B, C]) — convert dash-lists; drop
  5. Other keys are ignored, harmless — keep them.

What it can do on your machine

Read from SKILL.md and the folder at commit f187f45. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • git

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • raw.githubusercontent.com
    • api.github.com
    • w3.org

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Import Skill loads about 2.4k tokens when it runs. Until then it costs about 61 tokens; SKILL.md has 1,043 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~61
When it runs · the whole SKILL.md, loaded when a task matches
~2.4k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from rome-os/rome at commit f187f45, republished under its MIT licence (© rome-os). 1,043 words, ~2,359 tokens.

Download SKILL.mdSave it as .claude/skills/import-skill/SKILL.md (or your agent's skills folder).
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 form https://raw.githubusercontent.com/<owner>/<repo>/<ref>/<path>.
  • github.com/<owner>/<repo>/tree/<ref>/<dir> → list it via https://api.github.com/repos/<owner>/<repo>/contents/<dir>?ref=<ref> and download the SKILL.md plus its auxiliary files.
  • Bare repo → look for SKILL.md at the root, then under skills/.
  • 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.)

Show full SKILL.md (436 more words)Show less

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:

  1. Starts with a --- line and has a closing ---.
  2. name: is a single lowercase kebab-case line matching the install folder.
  3. description: is a single line — collapse folded (>) or multi-line ones.
  4. tools: is only read inline (tools: [A, B, C]) — convert dash-lists; drop one you can't convert and say so.
  5. 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).

<!-- Keep this layout in sync with rome_apps/dream/src/lib/user-skills-carrier.ts,
which scaffolds the same carrier for Dream's skill review. -->

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 must ship a logo and a minimal web UI, or it shows up in the Apps list as a broken-looking entry. Write the files below exactly; the manifest is schema-validated (assetVersion 12 hex chars, routing: "client", entry exports mount). Backfill these into an existing carrier that's missing them.

yaml
# user-skills/app.yaml
formatVersion: 2
id: user-skills
name: User Skills
version: 0.1.0
description: Skills imported or generated via the Skills app.
icon: assets/icon.svg
web:
  manifest: web/manifest.json
skills: []
svg
<!-- user-skills/assets/icon.svg -->
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" fill="none">
  <rect width="64" height="64" rx="14" fill="#6366F1"/>
  <path d="M33 14 21 32h7l-3 13 12-18h-7l3-13Z" fill="#fff" stroke="#fff" stroke-width="2" stroke-linejoin="round"/>
  <circle cx="44" cy="44" r="11" fill="#fff"/>
  <path d="M44 39v10M39 44h10" stroke="#6366F1" stroke-width="2.5" stroke-linecap="round"/>
</svg>
json
// user-skills/web/manifest.json
{
  "entry": "index.js",
  "styles": [],
  "assetVersion": "000000000001",
  "displayName": "User Skills",
  "navLabel": "User Skills",
  "routing": "client"
}
js
// user-skills/web/index.js — hand-written ESM, no build step.
export function mount(root) {
  root.innerHTML = `
    <div style="display:flex;min-height:100%;align-items:center;justify-content:center;font-family:var(--font-sans,sans-serif);color:var(--foreground,#111)">
      <div style="max-width:28rem;text-align:center;padding:3rem 2rem">
        <h1 style="font-size:1.25rem;font-weight:600;margin:0 0 .5rem">User Skills</h1>
        <p style="margin:0 0 1.25rem;font-size:.875rem;color:var(--muted-foreground,#666)">
          This app only carries the skills you import or generate.
          Browse, search, and manage them in the Skills app.
        </p>
        <a href="/apps/skills" id="open-skills" style="color:var(--primary,#6366f1);font-weight:500;text-decoration:none">Open Skills &rarr;</a>
      </div>
    </div>`;
  root.querySelector("#open-skills").addEventListener("click", (e) => {
    e.preventDefault();
    window.dispatchEvent(new CustomEvent("rome:host-navigate", { detail: { path: "/apps/skills" } }));
  });
}

Plus package.json: { "name": "user-skills", "private": true, "type": "module" } and an empty skills/ directory. If you later edit web/index.js, bump assetVersion to a new 12-hex string so the browser drops the cached bundle.

Then, for the confirmed skill:

  1. Write skills/<name>/SKILL.md plus any auxiliary files.
  2. Add skills/<name> to the skills: list in app.yaml.
  3. git add -A && git commit -m "Add skill <name>".
  4. Install: system:app_management with { "op": "install", "source": { "mode": "source", "path": "<carrier-abs-path>" } } — the daemon builds, packs, and installs in one step.

If a step fails, show the error, fix what you can, and say where things stand.

Verify

Call list_skills and confirm the new name is present. If it isn't, the catalog dropped it — almost always a frontmatter rule. Fix and re-install once; if it still doesn't appear, report what you tried. Once you've seen it listed, tell the guardian it's live: they can invoke it in any chat with /<name>, or find it in the Skills app.

© rome-os, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in rome_apps/skills/src/skills/import-skill of rome-os/rome.

Open the folder on GitHubat commit f187f45

Compare with similar skills

Import Skill next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Import Skill compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Import Skill this skillrome-os/rome737—~2.4kAutomated safety check: PassMIT
Asd Ste100danyuchn/asd-ste100-skill4.2k—~4.1kAutomated safety check: PassMIT
Simple Issue Descriptionevery-app/open-seo23k1 repos~1.2kAutomated safety check: PassMIT
Ponytail AuditDietrichGebert/ponytail159k—~1.4kAutomated safety check: PassMIT
Technical Writing Standardcursor/plugins10k10 repos~2.4kAutomated safety check: PassNone
Natural Japanese Business Writingcoji/natural-japanese1.9k—~2.1kAutomated safety check: PassMIT

Similar skills

  • Asd Ste100

    danyuchn/asd-ste100-skill

    A skill your agent uses when English text must be parsed without a human to resolve ambiguity — tool descriptions, error messages, inter-agent instructions, system prompts, status reports — and…

    4.2k GitHub stars~4.1k tokensUpdated 5 days ago
    Writing & ContentAuto-check passed

  • Simple Issue Description

    every-app/open-seo

    Turn a rough bug report, feature request, support note, or pull request into a short, plain-language issue focused on the problem and desired behavior.

    23k GitHub starsUsed in 1 repo~1.2k tokens
    Writing & ContentAuto-check passed

  • Ponytail Audit

    DietrichGebert/ponytail

    Quality audit of a whole repo: bugs, security holes, what breaks under real load, risky code without tests, slow paths, and what to delete, merge or split.

    159k GitHub stars~1.4k tokensUpdated today
    Writing & ContentAuto-check passed

  • Technical Writing Standard

    cursor/plugins

    Official

    Applies four layers of technical-writing rules to docs, RFCs, readmes, PR descriptions and commit messages so a tired engineer follows them on the first read.

    10k GitHub starsUsed in 10 repos~2.4k tokens
    Writing & ContentAuto-check passed

  • Natural Japanese Business Writing

    coji/natural-japanese

    Writes and edits Japanese business documents so they read clearly and naturally, removes AI-sounding phrasing and can score how AI-like a text reads.

    1.9k GitHub stars~2.1k tokensUpdated 1 mo ago
    Writing & ContentAuto-check passed

  • Pgjev

    realZachi/pg-jev

    Install, configure, query and explain pgjev (the jev PostgreSQL extension that filters, ranks and classifies rows with plain-language conditions via TypeSafe's Jev model).

    1.1k GitHub stars~2.9k tokensUpdated 3 days ago
    Writing & ContentAuto-check passed

More from rome-os/rome

All 18 skills in this repo

  • Color Audit

    rome-os/rome

    Audit a design system's color palette against measurable color-science disciplines — WCAG/APCA contrast of declared token pairs, perceptual (OKLCH) ramp uniformity, color-blindness safety of…

    737 GitHub stars~2.7k tokensUpdated today
    Auto-check passed

  • Secondary Text Audit

    rome-os/rome

    Audit the subordinate copy in a UI — section descriptions, field helper text, hints, card subtitles, empty-state body copy, tooltip bodies — against the secondary-text ruleset, and emit a per-string…

    737 GitHub stars~2.8k tokensUpdated today
    Auto-check passed

  • UX Semantics Audit

    rome-os/rome

    Audit an existing UI/UX design (React/JSX/TSX components, HTML, or generated app code) against a tiered ruleset of verifiable UX principles, and produce structured, evidence-cited findings that a…

    737 GitHub stars~2.1k tokensUpdated today
    Auto-check passed

  • Add OAuth Integration

    rome-os/rome

    Add a new Rome-managed OAuth integration for a third-party service so a user can delegate access by clicking Connect, and Rome can act on the service with the delegated token (the GitHub/Slack model…

    737 GitHub stars~3.6k tokensUpdated today
    Auto-check passed

  • Composio CLI

    rome-os/rome

    Help users operate the published Composio CLI to find the right tool, connect accounts, inspect schemas, execute tools, subscribe to trigger events with composio listen, script workflows with…

    737 GitHub stars~2.7k tokensUpdated today
    Auto-check passed

  • File Issue

    rome-os/rome

    File one GitHub issue from a description the user gives — classify it as a bug report, feature request, or task spec, gather what the body needs from the tracker and the code, ask the user only for…

    737 GitHub stars~1.7k tokensUpdated today
    Auto-check passed

Categories

Questions about Import Skill

What does Import Skill do?

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…. Import Skill is an agent skill from rome-os/rome.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.

When should I use Import Skill?

Import Skill fits situations like: tasks that involve Plain language and style rules.

How do I install Import Skill in Claude Code?

Run `npx skills add rome-os/rome --skill import-skill -a claude-code`. Or copy the skill folder (rome_apps/skills/src/skills/import-skill in rome-os/rome) into .claude/skills/import-skill in your project. Claude Code loads it when a task matches its description.

How do I install Import Skill in Codex?

Run `npx skills add rome-os/rome --skill import-skill -a codex`. Or copy the skill folder (rome_apps/skills/src/skills/import-skill in rome-os/rome) into .agents/skills/import-skill in your project. Codex loads it when a task matches its description.

Can I use Import Skill in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add rome-os/rome --skill import-skill -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/import-skill, .gemini/skills/import-skill, .github/skills/import-skill and .opencode/skills/import-skill in your project.

What does Import Skill need to run?

Going by SKILL.md and its folder, Import Skill needs the command-line tools its instructions call (git).

Does Import Skill access the network?

SKILL.md names 3 domains. In commands or code: raw.githubusercontent.com, api.github.com and w3.org; the agent is likely to contact these when it follows the instructions. This is read from the text; nothing was executed.

Is Import Skill safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Import Skill use?

Import Skill is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Import Skill use?

About 2.4k tokens (SKILL.md is roughly 9.4k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Import Skill?

Skills that share tags, products or a category with Import Skill: Asd Ste100 (danyuchn/asd-ste100-skill, 4.2k stars), Simple Issue Description (every-app/open-seo, 23k stars), Ponytail Audit (DietrichGebert/ponytail, 159k stars) and Technical Writing Standard (cursor/plugins, 10k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Import Skill?

rome-os (a GitHub organization) maintains it in rome-os/rome, which has 737 GitHub stars. The repository holds 18 skills in this directory. The repository was last updated on October 9, 2026.

Source: rome-os/rome on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.