Guide · Agent skill
How to use the Code Import agent skill
Updated · written with AI from the project's own documentation and checked against our catalogue data
The code-import skill is a plugin for an AI agent that reads an existing software repository once and writes a normalised snapshot of its structure into the project folder. This guide explains what the skill does, how to install it, how to trigger it with plain requests, and what it needs and avoids. By the end you will know how to get a repository mapped before an agent proposes changes to it.
Code Importnexu-io/open-design · Apache-2.0 Download the skill Quick start
- 1Download the ZIP. Download the code-import ZIP from this directory page. It contains open-design.json and SKILL.md.
- 2Install the skill. Unzip it into ~/.claude/skills/ for personal use, into a project's .claude/skills/ folder, or upload it under Settings → Capabilities → Skills in the Claude apps.
- 3Prepare the repository. Make a local checkout available through the open-design project import or by providing its path.
- 4Fill in the target stack. Complete the target stack form in the tool with framework, package manager, styling system and component library.
- 5Ask for the mapping. Request that the repository be mapped before any changes are proposed.
- 6Review the snapshot. Check the code/ folder, especially meta.json, to confirm the git SHA and walk time match what you expect.
What the code-import skill makes the agent do
The skill reads an existing repository's structure into the project working directory as a normalised snapshot. The agent can then analyse that snapshot instead of walking the whole file tree again on every turn.
The snapshot is written into a folder called code/ and includes index.json (file list with path, size, language and imports, plus detected framework and styling system), components.json (detected components with file path and props), routes.json (detected routing model) and meta.json (repository path, git SHA, time of walk and walk budget). Other steps in the workflow read these files, and the agent keeps working from them until the repository is imported again.
- Skips dependency and build folders such as node_modules, .git, .next, dist and build, and records them with a reason in index.json.
- Requires evidence before naming a framework, such as a declared dependency in package.json plus a build config like next.config or vite.config.
- Ignores commented-out imports when recording import edges.
- Stops after a time budget (the default described in the source is 60 seconds) so large monorepos do not stall a run.
Install the code-import skill
Download the ZIP for the skill from this directory page. The package contains open-design.json and SKILL.md. You can install it in one of three places depending on how you work.
For a personal setup, unzip it into ~/.claude/skills/ so it is available across your projects. For a single project, unzip it into that project's .claude/skills/ folder so it applies only there. If you use the Claude apps instead, open Settings, go to Capabilities, and upload the skill under Skills.
- Personal install: unzip into ~/.claude/skills/
- Project install: unzip into the project's .claude/skills/ folder
- Claude apps: Settings → Capabilities → Skills, then upload the ZIP
Prerequisites before you run it
The skill needs a local checkout of the repository. You can supply it through the open-design project import or by giving a path. It is run by the open-design daemon runner that implements it, and the workflow asks for a target stack through a form in the tool before the import step runs.
The target stack covers framework, package manager, styling system and component library. The skill runs scripts but does not use the network, according to its listing.
- A local checkout of the repository, via od project import or a path
- The open-design daemon runner that implements the skill
- A target stack filled in through the form in the tool
How to trigger the skill with natural requests
You do not need special syntax. Describe the migration or analysis you want, and the agent will use the skill when the task starts from an existing repository. The skill's own description is that it reads a repository's structure into the project working directory so the agent can analyse it without re-walking the tree.
Be specific about the repository and the goal. Mention that you want the project mapped before any changes are proposed, since that is the point of the snapshot.
- "Map this repository before you propose any changes to the styling system."
- "Import the existing web app and summarise its framework, components and routes."
- "Snapshot this project so we can plan a migration to a different framework."
Example workflow from import to plan
A typical run starts from a real repository that you import into open-design. The skill walks the checkout once and writes the code/ folder. Later steps, such as design extraction, rewrite planning and patch editing, read that folder instead of scanning the files again.
If the repository is empty, the run stops with an error so you can re-import it. If you change the repository substantially, re-import it, because the agent trusts the snapshot until you do.
- Import the repository through open-design or give its path.
- Fill in the target stack form.
- Let the skill write code/index.json, components.json, routes.json and meta.json.
- Review the plan the later steps produce, then re-import after major changes.
Safety notes: scripts and what is read
The skill runs scripts. Its walker indexes source file paths and contents such as imports, so an AI agent reads that material. Do not use it on repositories you do not want an AI agent to read.
Because the agent trusts the snapshot until a manual re-import, changes made after the walk will not appear in the analysis. Check meta.json for the git SHA and walk time to see what the snapshot reflects.
- Do not point it at private code you are not willing to have read by an AI agent.
- Re-import after edits, or the plan may describe an outdated repository.
- Dependency and build folders are skipped by design.
Tips for better results
Give the skill a clean checkout. Skipped folders are recorded, but a repository with generated or vendored code will still produce a larger snapshot. Fill in the target stack carefully, because the later steps depend on it.
Use it for projects large enough that a full map is useful. For a small script, the snapshot adds little value.
- Use a clean checkout of the repository.
- Fill in the target stack form accurately.
- Re-import the project after major changes.
- Skip it for small one-off scripts.
What people use it for
- Planning a migration of an existing web app to a different framework.
- Changing the styling system of a large project after mapping its components first.
- Mapping a monorepo's routes and components before a team discusses refactoring.
- Running a multi-step code-migration workflow in the open-design tool.
Frequently asked questions
How do I install the code-import skill?
Download the ZIP from this page and unzip it into ~/.claude/skills/ for personal use or into a project's .claude/skills/ folder. In the Claude apps, you can instead upload it under Settings → Capabilities → Skills.
What does the code-import skill require?
It requires a local checkout of the repository, supplied through the open-design project import or a path. It also needs the open-design daemon runner that implements it, and a target stack defined through a form in the tool.
Is the code-import skill free to use?
The skill is licensed under Apache-2.0. This page does not state pricing for any other part of the workflow, so check the open-design project for any costs of its tooling.
Does code-import use the internet?
According to its listing, the skill runs scripts but does not use the network. It reads the local repository checkout and writes the snapshot into the project folder.
What should I do if the import fails on an empty repository?
The skill stops with a clear error event when the repository is empty, because the snapshot needs at least one file entry. Check that the checkout is complete and re-import the project.
How is code-import different from letting the agent scan files each time?
Instead of re-scanning every file on each step, the skill walks the project once and stores a summary the agent reuses until the next manual re-import. This saves repeated scanning, but the snapshot can go stale if the code changes.
New agent skills, repos and AI tools — every week
The best new skills and open-source projects, the fastest-growing repos, and one free prompt. Five minutes to read. Unsubscribe anytime.
Our verdict
Use code-import if you are planning a migration or refactor of an existing web project and want an agent to map its structure once before proposing changes. Pick something else for small one-off scripts, for repositories you do not want an AI agent to read, or for projects that change so quickly that a snapshot would be out of date.
Download the skill