What is the main purpose of the Code Import skill?

The main purpose of Code Import is to create a normalized snapshot of a repository's structure, allowing for efficient analysis without the need to re-walk the file tree on every interaction.

How does Code Import handle large repositories?

Code Import respects a time budget during the import process, ensuring that large monorepos do not consume excessive resources and time, allowing for a more efficient workflow.

What types of files does Code Import analyze?

Code Import analyzes files relevant to the project structure, including components and routing models, while excluding unnecessary directories such as node_modules and .git.

Can Code Import be used for small projects?

While Code Import can technically be used for small projects, the overhead of setting it up may not be justified compared to the simplicity of directly analyzing the codebase.

What output does Code Import generate?

Code Import generates several JSON files, including index.json, components.json, routes.json, and meta.json, which collectively provide a comprehensive overview of the project's structure.

Code Import

Name: Code Import
Availability: InStock
Author: nexu-io

Free

Streamline repository analysis with normalized snapshots.

by nexu-io84.9k stars on nexu-io/open-design

3 views

Updated Aug 10, 2026

Get this skill

Free · Opens the source repo

What Code Import does

Code Import is a developer tool designed to enhance the efficiency of repository analysis by creating a normalized snapshot of a project's structure. By utilizing this skill, developers can avoid the repetitive task of re-walking the project tree during each interaction with the agent. Instead, Code Import generates a structured representation of the repository, which subsequent operations can reference without needing to traverse the file system again. This is particularly useful in large projects where traversing can be time-consuming and resource-intensive.

The skill operates by taking an existing repository, either imported via od project import or specified through a provided path, and transforming it into a comprehensive on-disk record. This record includes essential information such as file paths, sizes, languages, and component details, all stored in the code/index.json file. The skill also ensures that only relevant parts of the repository are analyzed, excluding unnecessary directories like node_modules and .git, which helps maintain focus on the project's core structure.

Code Import is ideal for developers who need to work with large codebases and require a quick way to gather insights without the overhead of continuous file system navigation. It is particularly beneficial in collaborative environments where multiple phases of development and migration occur, allowing teams to work efficiently with a shared understanding of the project's structure.

However, this skill may not be suitable for smaller projects where the overhead of setting up a normalized snapshot could outweigh the benefits. Additionally, if your workflow does not involve frequent analysis or migration of code, the advantages of using Code Import may not be fully realized.

When to use it

Use this skill when working with large codebases that require frequent analysis or migration tasks.

When not to use it

Avoid using it for small projects where the setup overhead may not be justified.

What you can build with it

Analyzing a Large Codebase

When working with a large repository, Code Import allows developers to quickly generate a snapshot of the project structure, making it easier to analyze components and routing.

Collaborative Development

In a team setting, Code Import helps maintain a consistent understanding of the project structure, facilitating smoother collaboration during code migration and refactoring.

Streamlining Code Reviews

Code Import provides a structured view of the repository, enabling more efficient code reviews by focusing on relevant components and dependencies.

How to install Code Import

View source

1. Install with the skills CLI

npx skills add nexu-io/open-design/code-import --agent claude-code

2. Or install it manually

Download the skill folder and drop it into ~/.claude/skills/ for all projects, or .claude/skills/ to scope it to one repo. Restart Claude Code so it picks up the new skill.

Anthropic's agentic coding CLI, and the reference implementation of Agent Skills. Drop a skill folder into ~/.claude/skills and Claude Code loads it automatically whenever a task matches the skill's description. Claude Code docs

Inside SKILL.md

Written by nexu-io

Code import

Spec §10 / §21.3.2: a code-migration / tune-collab run starts from a real repo (cloned via od project import or a path the user provided). This atom turns the raw checkout into a normalised on-disk record that subsequent atoms (design-extract, rewrite-plan, patch-edit) operate against. The point is to stop re-walking the tree on every turn — the agent reads code/index.json once and trusts the snapshot until the next explicit re-import.

Inputs

Source	Required	Notes
`repoPath`	yes	Absolute path to the repo's root, supplied via `od project import` or an upstream `od.context.assets[]` reference
`targetStack`	yes	{ framework, packageManager, styleSystem, componentLibrary } via the matching `form` GenUI surface

Output

project-cwd/
└── code/
    ├── index.json         # { files: { path, size, language, imports[] }[], packageJson?, lockfileKind, framework, styleSystem }
    ├── components.json    # detected components with file path + props snapshot
    ├── routes.json        # detected routing model (next/app, react-router, vite-router, …)
    └── meta.json          # { repoPath, gitSha, walkedAt, atomDigest, walkBudgetMs }

code/index.json is the input every other Phase 7 atom reads. The walk respects the runner's budgetMs option (default 60s) so large monorepos don't burn an entire run on import.

Convergence

The atom completes when code/index.json exists and contains at least one entry. Empty repos abort with a clear error event so the user re-imports.

Anti-patterns the prompt fragment forbids

Walking node_modules / .git / .next / dist / build (record in code/index.json.skipped[] with reason).
Inferring a framework from a single file; require at least package.json's declared dep + a build-config presence (next.config.*, vite.config.*, etc.).
Treating commented-out imports as live edges.

Status

Implemented by the daemon runner in apps/daemon/src/plugins/atoms/code-import.ts. The walker enforces its exclusions and time budget, detects framework evidence, and writes code/index.json.

Frequently asked questions about Code Import

Similar skills

Quality Playbook Generator

Run comprehensive quality audits on any codebase.

PR Draft Summary

Automate PR summary generation for openai-agents-python.

Final Release Review

Streamline your release candidate audits with ease.

Unit Test Vue Pinia

Efficiently write and review unit tests for Vue 3 applications.

Slang Shader Expert

Optimize and integrate Slang shaders with ease.

Telemetry Standards

Ensure consistent event tracking in Supabase Studio.