Skip to content
Skills Library
AI & agents · Conversion & formats

import-plugins

/import-plugins

Bring plugins the user already installed in Claude Code or Codex into Kiro, or import one straight from a marketplace GitHub URL. Use when the user mentions Claude Code plugins, Codex plugins, a plugin marketplace, or asks to bring, move, port or migrate their plugins to Kiro. Not for authoring a new plugin from loose files.

Licence
MIT
Last repository change
22.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
3
Scripts
1
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 22.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What to check before installing
  • 1 scripts in this package. Review them before installing, as Claude may execute them.

Scripts: scripts/kiro-port.py

What it does and when to use it

Bring plugins the user already installed in Claude Code or Codex into Kiro, or import one straight from a marketplace GitHub URL. Use when the user mentions Claude Code plugins, Codex plugins, a plugin marketplace, or asks to bring, move, port or migrate their plugins to Kiro. Not for authoring a new plugin from loose files.

Original author description

Bring plugins the user already installed in Claude Code or Codex into Kiro, or import one straight from a marketplace GitHub URL. Use when the user mentions Claude Code plugins, Codex plugins, a plugin marketplace, or asks to bring, move, port or migrate their plugins to Kiro. Not for authoring a new plugin from loose files.

How it works

  1. 1. See what there is
  2. 2. Port
  3. 3. Report back, then offer keywords
  4. 4. Removing
  5. What the script guarantees
Original SKILL.md headings · 103 lines, 739 words
SKILL.md preview
---
name: import-plugins
description: Bring plugins the user already installed in Claude Code or Codex into Kiro, or import one straight from a marketplace GitHub URL. Use when the user mentions Claude Code plugins, Codex plugins, a plugin marketplace, or asks to bring, move, port or migrate their plugins to Kiro. Not for authoring a new plugin from loose files.
---

# Import Claude Code / Codex plugins into Kiro

A script does the conversion. You run it, read its report back to the user, and help with the one
decision it refuses to make: activation keywords. **Never edit plugin contents yourself** — the
script copies bodies byte-for-byte and stops if one differs, and that guarantee is the point of this
skill.

The script is at a fixed path. Set it once:

```bash
S=~/.kiro/powers/installed/plugin-importer/skills/import-plugins/scripts/kiro-port.py
```

If that path is missing, `ls ~/.kiro/powers/installed/*/skills/import-plugins/scripts/` to find it.
Never glob the home directory — it takes minutes and finds nothing useful.

## 1. See what there is

```bash
python3 $S scan                      # what Claude Code and Codex have installed
python3 $S scan --from <source>      # a marketplace or plugin repo: URL, owner/repo, or local path
```

`scan` prints each plugin's components and where it recommends putting them. Show that list grouped
by tool. Project-scoped Claude Code installs appear only when Kiro runs inside that project, matching
Claude Code's own visibility.

With `--from`, entries whose source points at another git repository print as `remote: <url>`. `port`
fetches only the ones you name, so always pass explicit names unless the marketplace is small.

**Ask which ones rather than defaulting to everything.** Each Power the user does not need is context
they pay for every session, and plugins carrying `node_modules` can exhaust the editor's file
descriptors — the script excludes those trees and warns past 2,000 files.

## 2. Port

```bash
python3 $S port <name>[@<market>] ...          # or --all
python3 $S port --from <source> <name>...
```

Follow the recommendation from `scan` unless the user wants otherwise:

| Plugin holds | Goes to |
|---|---|
| `commands/` or `.mcp.json` | a Power — only a Power can carry those |
| skills (hooks and agents may come along) | `~/.kiro/skills/`, plus `~/.kiro/hooks/` and `~/.kiro/agents/` |
| hooks or agents but no skills | a Power |
| Markdown guidance only | nothing is moved; report the `~/.kiro/steering/` path and stop |

`--as skills` and `--as power` override it. `--as skills` on a plugin with commands or MCP drops
those, and the script says so. `--slash` also exposes a Power's skills as `/name` slash commands
(symlinks under `~/.kiro/skills/`) — use it when the user wants to pick one skill out of a bundle
the way they did with `/command` in Claude Code, or asks for slash commands. `--project-local` writes into the current project's `.kiro/` instead of
installing globally. `--out DIR` only generates, which is how you turn a marketplace into a
Kiro-installable monorepo. `--smoke` checks that Kiro loads the result.

## 3. Report back, then offer keywords

For each plugin:

1. Say what came over and what the report marked `❌` or `⚠️`. **Do not soften the losses.** See
   `references/kiro-mapping.md` for what each one means.
2. `keywords` were derived from names only. Read the plugin's description and its skills'
   `description` lines, then append to the report:

   ```
   ## Suggested keywords
   Phrases the user would actually type when this Power should activate. Add them to
   plugin.json's keywords to apply.
   - commit       — requests like "commit this", "commit my changes"
   - open a PR    — …
   ```

   Three to six phrases in the user's language (Korean, English, or whatever they use), each with
   the situation it covers. **Recommend only** —
   do not write them into `plugin.json` unless asked.
3. Tell them to start a new session. Powers and skills load at session start.
4. If the plugin went into a Power (skills stayed inside it, not `~/.kiro/skills/`), mention that its
   skills resolve by plain-language request in a `kiro-cli --v3` session (a native `Kiro Powers` tool
   reads them by name) — but only there. In classic mode or `--no-interactive`, that tool isn't
   available and asking by name won't reliably find it; giving the skill's exact path
   (`~/.kiro/powers/installed/<plugin>/skills/<skill>/SKILL.md`) is the fallback that works everywhere.

## 4. Removing

```bash
python3 $S unport <name>
```

Removes everything the import installed — Power, skills, hooks, agents, supporting files — and leaves
the original plugin untouched.

## What the script guarantees

- Skill, command and agent bodies and hook scripts are copied byte-for-byte, asserted after the copy.
- The only body edit is `${CLAUDE_PLUGIN_ROOT}` → the installed path.
- `.claude-plugin/`, `commands/`, `agents/` stay in place, so the same directory still works as a
  Claude Code plugin.
- Anything Kiro has no equivalent for is reported, never approximated.
- Powers it did not create are never overwritten.
Files in this package (3)
  • SKILL.md 5 KB
  • references/kiro-mapping.md 10 KB
  • scripts/kiro-port.py 57 KB

Versions

The database has no other skills named import-plugins.

Database snapshot: 13.11.2026 · package version 4ffb89c96db3 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 90Codex CLI Plugins
    This skill should be used when the user asks to "create a Codex plugin", "build a plugin for Codex CLI", "package a Codex skill", "set up a Codex marketplace", "publish a Codex plugin", "configure plugin.json manifest", "add MCP to a Codex plugin", "install a local plugin in…
  • 100claude-plugins
    Reference for building and distributing Claude Code plugins — plugin.json and marketplace.json structure, bundling commands, agents, skills and hooks, versioning, and publishing a marketplace. Use when creating or packaging a plugin, setting up a marketplace, or debugging why a…
  • 100plugin-marketplace-creator
    Create and configure Claude Code plugin marketplaces hosted on GitHub. Use this skill when users want to set up a new plugin marketplace repository, add plugins to an existing marketplace, configure team distribution settings, or troubleshoot marketplace issues. Triggers include…
  • 100migrate-agent-settings
    Migrates the user's MCP servers, skills, slash commands, subagents, and instruction files from other coding agents (Claude Code, Codex, Cursor, Gemini CLI) into one new Antigravity plugin. Use when the user wants to bring over, import, or migrate their setup or config from…
  • 90Claude Code Plugin Builder
    Creates Claude Code plugins with proper manifest structure, directory layout, and components (commands, agents, skills, hooks, MCP servers). This is for Claude Code plugins (`.claude-plugin/plugin.json`) — for Codex plugins (`.codex-plugin/plugin.json`) use the `plugin-creator`…
  • 100codex-plugin-discovery
    Use when a user asks what Codex plugins are available or can be used, wants plugin recommendations for a task, asks to find/search/discover installable plugins, asks about the plugin marketplace, or asks whether a plugin can help with a task.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.