# Bring your existing kit

Bring your AGENTS.md, CLAUDE.md, skills and agents into EasyCode, and see how each harness gets them in every session.

Your team may already have a kit: an `AGENTS.md`, a `CLAUDE.md`, a folder of skills, some agents. You don't need to
rewrite any of it. There are two kinds of kit file, and EasyCode treats them differently:

- **The org's shared kit** goes into the org [library](/guides/propose-a-library-change), so every session in every
  repo gets it, in every harness.
- **A repo's own files**, like `CLAUDE.md` or `.cursor/rules/`, stay in the repo. The harness reads them from the
  folder as it always has.

## Import a kit repo from the CLI

If your shared kit lives in a git repo, import all of it at once with [`easycode library import`](/reference/cli#library-import). It takes an org
admin.

### Sign in

Install the [CLI](/setup/cli) and run [`easycode login`](/reference/cli#login). It opens the browser to sign you in. Both commands need `EASYCODE_API_URL` set to your EasyCode address, as in [the CLI setup](/setup/cli).

### Run the import

```bash
EASYCODE_API_URL=https://app.easycode.studio pnpm easycode library import ~/code/northwind-kit --org northwind
```

Add `--propose` to open every asset as a change for review instead of publishing it.

### Read the report

Each asset is listed as **created**, **changed**, **unchanged** or **refused**, with the reason. A changed asset
opens as a change: the published version stays as it is until someone approves it.

The import reads the tip of the repo's default branch on its remote, not your working copy. Your local branch and
uncommitted edits are ignored, and symlinks are skipped.

### What becomes what

| In the kit repo                          | In the library              |
| ---------------------------------------- | --------------------------- |
| `AGENTS.md` at the root                  | Instruction                 |
| `skills/<name>/` (with `SKILL.md`)       | Skill, with its other files |
| `agents/<name>.md`                       | Agent                       |
| `knowledge/<name>.md`                    | Knowledge doc               |
| `knowledge/guides/<name>.md`             | Guide                       |
| `knowledge/standards/<name>.md`          | Standard                    |
| `knowledge/products/<product>/<name>.md` | Knowledge for that product  |
| `docs/…`                                 | Knowledge docs              |
| `.mcp.json` servers                      | MCP entries                 |

A literal secret in an `.mcp.json` server is imported as a reference instead, with a warning. Hooks in
`.claude/settings.json` are listed for you to review by hand and never imported. Files that match no rule are
counted, not sent.

## Import one file in the app

Org admins can add one asset at a time. In **Library**, press **Import**. Pick the kind and **Who is it for?** as for
any new asset, then choose where it comes from: **Paste text**, **Upload a file**, **A GitHub URL**, **A file in a
repo** or **The MCP registry**. A file can be at most 512 KB there. To import from GitHub, you need read access to
that repository.

## How each harness gets the kit

When a session starts in an org space, EasyCode builds the org's kit in the form its harness reads. The build sits
in EasyCode's own folder, read-only. Nothing is written into your repo or into the harness's home folder, so
`git status` stays clean.

| Harness     | Instructions                        | Skills and agents                            |
| ----------- | ----------------------------------- | -------------------------------------------- |
| Claude Code | Added to the system prompt          | A plugin, so skills and agents load natively |
| Codex       | Developer instructions              | Pointers                                     |
| Cursor      | Pointers at the start of the prompt | A plugin, so skills and agents load natively |
| Copilot     | Its custom instructions folders     | Skills natively; agents as pointers          |
| Gemini      | An included directory               | Pointers                                     |
| OpenCode    | Its config's instructions           | Pointers                                     |
| pi          | Added to the system prompt          | Skills natively; agents as pointers          |

A **pointer** is a line in the instructions with the asset's name, description and the path of its file. The harness
reads that file with its own tools when the task calls for it. Pointers are also the fallback: if a harness refuses a
channel, that part goes into the first prompt as pointers and the session shows "org context limited".

A rule renders as "When working in" its paths, in every harness. MCP entries build for Claude Code and Codex only. To
see what one asset turns into for each harness, open its change and look at **Output per harness**.

For each harness's details, see [Harness matrix](/reference/harnesses).

## Your repo's own files

EasyCode doesn't import a repo's `CLAUDE.md`, `GEMINI.md`, `.cursorrules`, `.github/copilot-instructions.md` or the
harness folders under `.claude/`, `.cursor/` and `.github/`. They stay in the repo, the harness loads them, and the
session's chip names them, for example "this repo's AGENTS.md".

When the org's instructions and the repo's own files disagree, Claude Code and Codex follow the org's; OpenCode and
Cursor follow the repo's `AGENTS.md`. The chip doesn't flag a conflict, so keep the two in step.

Once [knowledge](/guides/set-up-knowledge) is set up, the org map lists every repo's harness files, so a session can
find a rule that lives in another repo.

## Related

- [Propose and publish a library change](/guides/propose-a-library-change)
- [`easycode` CLI](/reference/cli)
