<SYSTEM>Full aix documentation with all guides and references</SYSTEM>

# aix add

> Add items to your configuration.

Adds skills, MCP servers, rules, or prompts to `ai.json` (or `ai.local.json`) and installs them to editors in one step. If no `ai.json` exists in the current directory, the item is installed directly to editors without modifying any config file.

## Commands

[Section titled “Commands”](#commands)

### `aix add skill`

[Section titled “aix add skill”](#aix-add-skill)

```bash
aix add skill <source> [flags]
```

**Flags:**

* `--name <name>` / `-n`: Override skill name.
* `--ref <ref>` / `-r`: Git branch/tag/commit.
* `--no-install`: Skip the install step after adding.
* `--local` / `-l`: Add to `ai.local.json`.
* `--scope <scope>` / `--user` (`-u`) / `--project` (`-p`): Target user-level or project-level config.

**Sources:**

* `react` (npm package `aix-skill-react`)
* `@scope/pkg`
* `github:user/repo`
* `owner/repo/path-to-skill`
* `https://github.com/org/repo/tree/main/skills/my-skill`
* `https://github.com/org/repo/blob/main/skills/my-skill/SKILL.md`
* `./local/path`

`aix add skill` stores native aix skill references in `ai.json` and installs skills through aix’s own resolver/installer flow. Skills are copied into `.aix/skills/{name}/`, then symlinked into editors with native skill support.

### `aix add mcp`

[Section titled “aix add mcp”](#aix-add-mcp)

```bash
aix add mcp <name> [flags]
```

If no command/url is provided, it searches the registry.

**Flags:**

* `--command <cmd>`: Command to run (stdio).
* `--args <args>`: Command arguments.
* `--url <url>`: HTTP/SSE URL.
* `--env <vars>`: Environment variables (`KEY=val,KEY2=val`).
* `--no-install`: Skip the install step after adding.
* `--local` / `-l`: Add to `ai.local.json`.
* `--scope <scope>` / `--user` (`-u`) / `--project` (`-p`): Target user-level or project-level config.

### `aix add rule`

[Section titled “aix add rule”](#aix-add-rule)

```bash
aix add rule <source> [flags]
```

**Flags:**

* `--name <name>` / `-n`: Rule name.
* `--activation <mode>` / `-a`: `always`, `auto`, `glob`, or `manual`.
* `--globs <patterns>` / `-g`: Glob patterns (comma separated).
* `--description <desc>` / `-d`: Description for auto-activation.
* `--ref <ref>` / `-r`: Git branch/tag/commit.
* `--no-install`: Skip the install step after adding.
* `--local` / `-l`: Add to `ai.local.json`.
* `--scope <scope>` / `--user` (`-u`) / `--project` (`-p`): Target user-level or project-level config.

### `aix add prompt`

[Section titled “aix add prompt”](#aix-add-prompt)

```bash
aix add prompt <source> [flags]
```

**Flags:**

* `--name <name>` / `-n`: Prompt name.
* `--description <desc>` / `-d`: Command description.
* `--argument-hint <hint>`: Hint for user arguments.
* `--ref <ref>` / `-r`: Git branch/tag/commit.
* `--no-install`: Skip the install step after adding.
* `--local` / `-l`: Add to `ai.local.json`.
* `--scope <scope>` / `--user` (`-u`) / `--project` (`-p`): Target user-level or project-level config.

---

# aix backups

> View and manage configuration backups.

Configuring editors can be destructive. `aix` creates backups of every file it modifies before writing to it.

## Backup Locations

[Section titled “Backup Locations”](#backup-locations)

* **Local**: `.aix/.tmp/backups/` — Backups of files within your project.
* **Global**: `~/.aix/backups/` — Backups of global editor config files (e.g., Windsurf’s `mcp_config.json`).

## Commands

[Section titled “Commands”](#commands)

### `aix backups`

[Section titled “aix backups”](#aix-backups)

List all available backups.

## Automatic Cleanup

[Section titled “Automatic Cleanup”](#automatic-cleanup)

Backups are automatically cleaned up based on the settings in `ai.json`:

```json
{
   "aix": {
      "cache": {
         "maxBackups": 5,
         "maxBackupAgeDays": 30
      }
   }
}
```

---

# aix cache

> Manage the local cache.

aix caches downloaded rules and remote configs in `.aix/.tmp/cache/`. Skills are stored separately in `.aix/skills/`.

## Usage

[Section titled “Usage”](#usage)

```bash
aix cache clear
```

Alias: `aix cache clean`

Removes all cached files under `.aix/.tmp/`. They will be re-downloaded on the next `aix install`.

---

# aix config

> View and modify raw configuration values.

Interact with config values using dot-notation keys.

## Commands

[Section titled “Commands”](#commands)

### `aix config show`

[Section titled “aix config show”](#aix-config-show)

Show the full configuration.

**Flags:**

* `--resolved` / `-r`: Show the final merged config (after `extends` and `ai.local.json`).

### `aix config get`

[Section titled “aix config get”](#aix-config-get)

Get a specific value.

```bash
aix config get mcp.github.env
```

### `aix config set`

[Section titled “aix config set”](#aix-config-set)

Set a value. JSON strings are automatically parsed.

```bash
aix config set rules.my-rule.activation auto
```

---

# aix init

> Initialize a new configuration.

Creates a new `ai.json` file in the current directory.

## Usage

[Section titled “Usage”](#usage)

```bash
aix init [flags]
```

## Flags

[Section titled “Flags”](#flags)

| Flag                                       | Description                                       |
| ------------------------------------------ | ------------------------------------------------- |
| `--force` / `-f`                           | Overwrite existing `ai.json` if it exists.        |
| `--from <editor>`                          | Import supported config from an existing editor.  |
| `--extends <ref>`                          | Set the `extends` reference in the new `ai.json`. |
| `--lock`                                   | Create `ai.lock.json` beside the new config.      |
| `--scope <scope>` / `--user` / `--project` | Set the `scope` field (`user` or `project`).      |

The `--extends` flag accepts any reference type: local paths, URLs, git repos, or npm packages.

```bash
# Initialize with an extends reference
aix init --extends github:company/ai-config


# Initialize with a lockfile
aix init --lock


# Initialize a user-scoped config
aix init --scope user


# Combine both
aix init --extends github:company/ai-config --scope user
```

## Importing Config

[Section titled “Importing Config”](#importing-config)

The `--from` flag lets you bootstrap `ai.json` from:

* `cursor`
* `copilot`
* `windsurf`
* `claude-code`
* `zed`
* `codex`
* `gemini`
* `opencode`

When importing, aix will:

1. Read the editor’s config files.
2. Extract rules, prompts, and MCP settings.
3. Write extracted content to `.aix/imported/`.
4. Generate an `ai.json` linking to those files.

`aix init --from` is the right command when you want `ai.json` to become the source of truth. If you want direct editor-to-editor migration, use [`aix sync`](/cli/sync/).

See [Import from an Editor](/getting-started/import-from-editor/) for details.

---

# aix install

> Apply ai.json configuration to editors.

Reads `ai.json` (and `ai.local.json`), resolves all inheritance, and writes configuration files for supported editors.

This command starts from `ai.json`. If you want to copy supported config directly from one editor to another, use [`aix sync`](/cli/sync/) instead.

You can also install a single item without a local `ai.json` by passing `--type`.

## Usage

[Section titled “Usage”](#usage)

```bash
aix install [source] [flags]
```

If `source` is provided without `--type`, it must be an `ai.json` config source. If `source` is provided with `--type`, aix installs that one item directly and does not create or modify `ai.json`.

## Flags

[Section titled “Flags”](#flags)

| Flag                                                     | Description                                                                           |
| -------------------------------------------------------- | ------------------------------------------------------------------------------------- |
| `--target <editor>` / `-t`                               | Limit installation to specific editors. Repeatable.                                   |
| `--type <type>`                                          | Directly install one `mcp`, `skill`, `rule`, `hook`, or `prompt` without `ai.json`.   |
| `--name <name>` / `-n`                                   | Name for a direct install when aix cannot infer one.                                  |
| `--ref <ref>` / `-r`                                     | Git ref for direct install sources.                                                   |
| `--command <command>`                                    | Command for direct MCP stdio installs.                                                |
| `--args <args>`                                          | Comma-separated command arguments for direct MCP installs.                            |
| `--env <vars>`                                           | Comma-separated `KEY=value` env vars for direct MCP installs.                         |
| `--url <url>`                                            | Remote Streamable HTTP MCP URL for direct MCP installs.                               |
| `--header <header>`                                      | HTTP header for direct remote MCP installs. Repeatable `KEY=value`.                   |
| `--description <text>`                                   | Rule or prompt description for direct installs.                                       |
| `--activation <mode>`                                    | Rule activation mode for direct rule installs.                                        |
| `--globs <patterns>`                                     | Comma-separated glob patterns for direct rule installs.                               |
| `--argument-hint <hint>`                                 | Prompt argument hint for direct prompt installs.                                      |
| `--dry-run` / `-d`                                       | Preview changes without writing files.                                                |
| `--save`                                                 | When installing a remote source, save it to local `ai.json`.                          |
| `--overwrite`                                            | With `--save`, overwrite local config instead of merging.                             |
| `--clean`                                                | Remove the `.aix` folder before install to ensure a fresh state.                      |
| `--copy`                                                 | With `--save`, copy remote files to `.aix/imported/` instead of referencing git URLs. |
| `--lock`                                                 | Create or refresh `ai.lock.json` before installing.                                   |
| `--only <field>`                                         | Limit to specific fields: `rules`, `prompts`, `mcp`, `skills`, `hooks`, `agents`.     |
| `--scope <scope>` / `--user` (`-u`) / `--project` (`-p`) | Override the `scope` from `ai.json` (target user-level or project-level config).      |

## Examples

[Section titled “Examples”](#examples)

**Standard install:**

```bash
aix install
```

**Install only to GitHub Copilot:**

```bash
aix install --target copilot
```

**Install a remote config directly:**

```bash
aix install github:company/ai-config
```

**Install remote config and save it to your local ai.json:**

```bash
aix install github:company/ai-config --save
```

**Install only MCP servers:**

```bash
aix install --only mcp
```

**Directly install a user-scope MCP server without ai.json:**

```bash
aix install playwright --type mcp --target claude-code --user
```

An HTTPS MCP source is treated as a remote Streamable HTTP endpoint:

```bash
aix install https://example.com/mcp --type mcp --name docs --target claude-code --user
```

**Directly install one local item:**

```bash
aix install ./skills/review --type skill --target claude-code --user
aix install ./rules/typescript.md --type rule --name typescript --target cursor
aix install ./prompts/review.md --type prompt --name review --target opencode --user
aix install ./hooks/pre-command.jsonc --type hook --target claude-code --user
```

Direct installs require `--target` and do not persist anything to `ai.json`.

**Refresh the lockfile, then install:**

```bash
aix install --lock
```

`--lock` with a remote source requires `--save`, because aix needs a local `ai.json` to write `ai.lock.json` beside.

**Override scope to install as user-level config:**

```bash
aix install --scope user
```

## install vs sync

[Section titled “install vs sync”](#install-vs-sync)

* `aix install` is `ai.json -> editor`
* `aix sync` is `editor -> aix bridge -> editor`

That split matters. `install` applies your shared config. `sync` is for migrating or copying existing editor config between supported editors.

---

# aix list

> List configured or installed AI configuration items.

Display what is currently configured in your project. Items are labeled with their scope (user/project).

## Usage

[Section titled “Usage”](#usage)

```bash
aix list [subcommand]
```

## Commands

[Section titled “Commands”](#commands)

* `aix list skills`: Show configured skills.
* `aix list mcp`: Show configured MCP servers and their status.
* `aix list rules`: Show active rules and activation modes.
* `aix list prompts`: Show configured prompts.
* `aix list editors`: Show detected/configured editors.

## Flags

[Section titled “Flags”](#flags)

| Flag                                                     | Description                                                 |
| -------------------------------------------------------- | ----------------------------------------------------------- |
| `--only <field>`                                         | Filter by section: `rules`, `prompts`, `mcp`, `skills`.     |
| `--scope <scope>` / `--user` (`-u`) / `--project` (`-p`) | Filter by user-level or project-level config.               |
| `--all`                                                  | List all editor config, including items not managed by aix. |
| `--editor <name>` / `-e`                                 | Limit `--all` output to specific editors. Repeatable.       |
| `--json`                                                 | Output as JSON.                                             |

Use `aix list --all` to inspect actual editor files, including symlinked native skills and externally managed items.

---

# CLI overview

> High-level overview of the aix CLI.

The `aix` CLI is your primary tool for managing AI agent configurations. It follows a syntax similar to `npm`.

## Global Flags

[Section titled “Global Flags”](#global-flags)

These flags are available on all commands:

| Flag                     | Description                                                                         |
| ------------------------ | ----------------------------------------------------------------------------------- |
| `--config <path>` / `-c` | Path to `ai.json` (defaults to current dir). Can also be set via `$AI_JSON_CONFIG`. |
| `--quiet` / `-q`         | Suppress non-essential output.                                                      |
| `--json`                 | Output results as JSON.                                                             |

## Command Groups

[Section titled “Command Groups”](#command-groups)

* **Core**: `init`, `install`, `sync`, `validate`
* **Management**: `add`, `remove`, `list`
* **Discovery**: `search`
* **Config**: `config get`, `config set`, `config show`
* **System**: `cache`, `backups`, `global`

`init --from` and `sync` sound similar, but they solve different problems:

* `aix init --from <editor>` reads an editor and writes a new `ai.json`.
* `aix sync <from> --to <to>` reads one editor and writes the supported equivalent into the destination editor.
* `aix install` reads `ai.json` and applies it to one or more editors.

## Aliases

[Section titled “Aliases”](#aliases)

| Command       | Alias         |
| ------------- | ------------- |
| `install`     | `i`           |
| `list`        | `ls`          |
| `cache clear` | `cache clean` |

## Environment Variables

[Section titled “Environment Variables”](#environment-variables)

* `AI_JSON_CONFIG`: Override the default `ai.json` path.
* `AIX_LOG_LEVEL`: Set detailed logging (`debug`, `info`, `warn`, `error`).

---

# aix remove

> Remove items from your configuration.

Removes items from `ai.json` (or `ai.local.json`) and uninstalls them from editors in one step. If no `ai.json` exists in the current directory, the item is uninstalled directly from editors.

For skills, aix removes both the managed `.aix/skills/{name}/` copy and any native editor link for the selected scope before regenerating pointer-style rule output where needed.

## Usage

[Section titled “Usage”](#usage)

```bash
aix remove <type> <name> [flags]
```

## Commands

[Section titled “Commands”](#commands)

### `aix remove skill`

[Section titled “aix remove skill”](#aix-remove-skill)

```bash
aix remove skill react
```

### `aix remove mcp`

[Section titled “aix remove mcp”](#aix-remove-mcp)

```bash
aix remove mcp github
```

Also cleans up global MCP config if the server is no longer used by any project.

## Flags

[Section titled “Flags”](#flags)

| Flag                                                     | Description                                    |
| -------------------------------------------------------- | ---------------------------------------------- |
| `--local` / `-l`                                         | Remove from `ai.local.json`.                   |
| `--yes` / `-y`                                           | Skip confirmation prompt.                      |
| `--no-delete`                                            | Skip deleting files from editors (for skills). |
| `--no-sync`                                              | Skip syncing editor config (for MCP).          |
| `--scope <scope>` / `--user` (`-u`) / `--project` (`-p`) | Target user-level or project-level config.     |

---

# aix search

> Find skills and MCP servers.

Interactive search tool for discovering capabilities across the skills.sh library and the [official MCP Registry](https://registry.modelcontextprotocol.io).

## Usage

[Section titled “Usage”](#usage)

```bash
aix search [query] [flags]
```

Without arguments, it opens an interactive TUI (Terminal User Interface).

## Interactive Mode

[Section titled “Interactive Mode”](#interactive-mode)

```bash
aix search
```

* **Up/Down**: Navigate results
* **Enter**: Select/Install
* **Tab**: Switch between Skills and MCP tabs
* **Ctrl+C**: Exit

## Flags

[Section titled “Flags”](#flags)

| Flag                      | Description                             |
| ------------------------- | --------------------------------------- |
| `--type <type>` / `-t`    | Filter by type: `skills`, `mcp`.        |
| `--plain` / `-p`          | Output as plain text (non-interactive). |
| `--registry <url>` / `-r` | Custom npm registry URL.                |

## JSON Output

[Section titled “JSON Output”](#json-output)

Use with `--plain --json` for scripts:

```bash
aix search react --type skills --plain --json
```

Interactive skill installs resolve Skills Library results to concrete repo paths, then call `aix add skill`, so search installs are saved and installed through the same native aix skill flow as manual adds.

---

# aix sync

> Copy supported configuration from one editor to another.

Reads supported config from one editor and installs the supported equivalent into another.

This command is for `editor -> editor` migration. If you want to apply `ai.json`, use [`aix install`](/cli/install/). If you want to create `ai.json` from an editor, use [`aix init --from`](/cli/init/).

## Usage

[Section titled “Usage”](#usage)

```bash
aix sync <from> --to <to> [flags]
```

`from` and `to` must be different supported editors.

## Flags

[Section titled “Flags”](#flags)

| Flag                     | Description                                          |
| ------------------------ | ---------------------------------------------------- |
| `--to <editor>` / `-t`   | Destination editor.                                  |
| `--scope <scope>` / `-s` | Apply the same scope to both source and destination. |
| `--from-scope <scope>`   | Scope to read from on the source editor.             |
| `--to-scope <scope>`     | Scope to write to on the destination editor.         |
| `--dry-run` / `-d`       | Preview changes without writing files.               |

Supported scope values are `user` and `project`.

If you do not pass any scope flags, sync defaults to `user` for both read and write.

## Examples

[Section titled “Examples”](#examples)

**Sync user-level config from Cursor to Claude Code:**

```bash
aix sync cursor --to claude-code
```

**Sync project-level config from Cursor to Zed:**

```bash
aix sync cursor --to zed --scope project
```

**Read project config but write user config:**

```bash
aix sync opencode --to windsurf --from-scope project --to-scope user
```

**Preview what would change:**

```bash
aix sync cursor --to codex --dry-run
```

## What sync does

[Section titled “What sync does”](#what-sync-does)

1. Reads supported config from the source editor.
2. Installs the supported equivalent into the destination editor.
3. Reports anything the destination could not represent.

## Partial syncs and skipped writes

[Section titled “Partial syncs and skipped writes”](#partial-syncs-and-skipped-writes)

Some editors simply cannot represent every feature from every other editor. Sync does not turn that into a hard failure.

Instead, aix calls out what was skipped and why. Two common reasons:

* The destination editor does not support that feature at all.
* The destination editor supports it, but not at the requested scope.

Examples:

* Codex converts prompts into skills instead of installing native prompts.
* Zed exposes skills through pointer rules, not native skill files.
* Windsurf and Codex still have global-only paths for some MCP writes, so a project-scoped sync will skip those writes and say so.

## Output expectations

[Section titled “Output expectations”](#output-expectations)

The command summary includes:

* what aix imported from the source editor
* which destination files changed
* global-only changes that were applied or skipped
* warnings for unsupported destination features
* warnings for target-scope limitations

Those limitation warnings are informational. They tell you what did not make the trip.

---

# aix validate

> Verify your ai.json configuration.

Validates `ai.json` against the schema and checks for logical errors (e.g., missing files, invalid rule activation modes).

## Usage

[Section titled “Usage”](#usage)

```bash
aix validate
```

If errors are found, it prints the JSON path to the invalid field and a description of the error. It exits with code 1 on failure.

## Lockfiles

[Section titled “Lockfiles”](#lockfiles)

```bash
aix validate --lock
```

`--lock` creates or refreshes `ai.lock.json` beside `ai.json`. After that, plain `aix validate` also checks the lockfile and fails if the resolved config has changed.

---

# Agents

> Specialized primary agents and subagents in aix.

Agents are reusable instruction profiles for specialized work. Define them once in `ai.json`; aix writes them to each editor’s native agent location when that editor has a documented file format.

```json
{
   "agents": {
      "code-reviewer": {
         "description": "Review code changes before a PR",
         "mode": "subagent",
         "model": "sonnet",
         "tools": ["Read", "Grep"],
         "permissions": {
            "edit": "deny",
            "bash": "ask"
         },
         "content": "Review the current diff for bugs and missing tests."
      }
   }
}
```

Use `mode: "subagent"` for delegated specialists and `mode: "primary"` for editors that support switching the main assistant profile. The portable fields are `description`, `mode`, `model`, `tools`, `permissions`, `mcp`, and the instruction source.

Editor-specific fields live under `editor`:

```json
{
   "agents": {
      "tester": {
         "content": "Test the changed behavior.",
         "editor": {
            "gemini": {
               "temperature": 0.2,
               "maxTurns": 8
            }
         }
      }
   }
}
```

Supported native destinations:

* Claude Code: `.claude/agents/*.md` and `~/.claude/agents/*.md`
* Cursor: `.cursor/agents/*.md` and `~/.cursor/agents/*.md`
* GitHub Copilot: `.github/agents/*.md` and `~/.config/github-copilot/agents/*.md`
* Gemini: `.gemini/agents/*.md` and `~/.gemini/agents/*.md`
* OpenCode: `.opencode/agents/*.md` and `~/.config/opencode/agents/*.md`

Codex, Windsurf, and Zed do not currently have aix-managed custom agent files. aix reports configured agents as unsupported for those editors instead of writing a lossy fallback.

---

# Hooks

> Trigger scripts on AI lifecycle events across every supported editor.

**Hooks** run scripts in response to lifecycle events (a session starts, a tool is about to run, a model response just landed, …). aix lets you author one set of hooks in `ai.json` and translates each one into the native format of every target editor.

## Usage

[Section titled “Usage”](#usage)

Define hooks in `ai.json`:

```json
{
   "hooks": {
      "session_start": [
         {
            "matcher": ".*",
            "hooks": [{ "command": "./scripts/init-session.sh", "show_output": true }]
         }
      ],
      "pre_tool_use": [
         {
            "matcher": "Bash",
            "hooks": [{ "command": "./scripts/audit-bash.sh" }]
         }
      ]
   }
}
```

When you run `aix install`, each enabled editor adapter translates that block into the editor’s native config format and writes it to the right file. Unsupported events are warned about — never silently dropped.

To install one hook fragment without creating `ai.json`, use direct install:

```bash
aix install ./hooks/pre-command.jsonc --type hook --target claude-code --user
```

## Hook events

[Section titled “Hook events”](#hook-events)

aix defines a normalized event vocabulary covering every event surfaced by the supported editors. Adapters map each to the editor’s native equivalent.

### Lifecycle

[Section titled “Lifecycle”](#lifecycle)

* `session_start`, `session_end`
* `setup` (Claude Code’s `--init-only` / `--init` / `--maintenance`)

### Prompt

[Section titled “Prompt”](#prompt)

* `pre_prompt` — before submitting the user’s prompt
* `user_prompt_expansion` — when a slash command expands into its body

### Tool execution

[Section titled “Tool execution”](#tool-execution)

* `pre_tool_use`, `post_tool_use`, `post_tool_use_failure`
* `post_tool_batch` — after a parallel tool batch finishes
* `pre_tool_selection` — before the model decides which tools it can call
* `permission_request`, `permission_denied`
* `pre_file_read`, `post_file_read`
* `pre_file_write`, `post_file_write`
* `pre_command`, `post_command`
* `pre_mcp_tool`, `post_mcp_tool`
* `pre_tab_file_read`, `post_tab_file_edit` (Cursor Tab)

### Model

[Section titled “Model”](#model)

* `pre_model_request` — before sending a request to the LLM
* `post_model_response` — when the LLM emits a response
* `pre_response_chunk` — for every streaming chunk

### Agent / response

[Section titled “Agent / response”](#agent--response)

* `pre_agent`, `post_agent`
* `post_response`, `post_response_with_transcript`
* `agent_stop`, `subagent_start`, `subagent_stop`, `subagent_idle`

### System / context

[Section titled “System / context”](#system--context)

* `pre_compact`, `post_compact`
* `task_created`, `task_completed`
* `worktree_setup`, `worktree_remove`
* `instructions_loaded`, `config_change`, `cwd_changed`, `file_changed`
* `notification`, `elicitation`, `elicitation_result`, `error_occurred`

## Hook action fields

[Section titled “Hook action fields”](#hook-action-fields)

Every action under `hooks[].hooks[]` accepts an optional set of fields. Adapters use whatever the target editor surfaces and report the rest via install-time warnings.

| Field                                 | Purpose                                                                                                                    |
| ------------------------------------- | -------------------------------------------------------------------------------------------------------------------------- |
| `type`                                | `command` (default), `http`, `mcp_tool`, `prompt`, or `agent`.                                                             |
| `command`                             | Shell command to run.                                                                                                      |
| `bash` / `powershell`                 | Cross-platform commands. Used directly by Copilot and Windsurf; Claude Code expands to two entries with `shell` selectors. |
| `shell`                               | `bash` or `powershell` selector when only one of the command fields is set.                                                |
| `cwd` / `working_directory`           | Working directory for the command.                                                                                         |
| `env`                                 | Environment variables to pass through (Copilot only today).                                                                |
| `timeout`                             | Timeout in seconds. Adapters convert (Gemini uses milliseconds, Copilot uses `timeoutSec`).                                |
| `async` / `async_rewake`              | Background execution (Claude Code).                                                                                        |
| `if`                                  | Permission-rule guard expression (Claude Code).                                                                            |
| `status_message`                      | Custom spinner message (Claude Code).                                                                                      |
| `once`                                | Run once per session (Claude Code skill / agent frontmatter).                                                              |
| `url`, `headers`, `allowed_env_vars`  | HTTP webhook fields (Claude Code `http`).                                                                                  |
| `mcp_server`, `mcp_tool`, `mcp_input` | MCP tool dispatch (Claude Code `mcp_tool`).                                                                                |
| `prompt`, `model`                     | LLM-evaluated prompt or agent (Claude Code, Cursor, Copilot `sessionStart`).                                               |
| `description`, `name`                 | Documentation / log identifier.                                                                                            |
| `fail_closed`                         | Block the action when the hook itself fails (Cursor).                                                                      |
| `loop_limit`                          | Max auto-triggered follow-ups (Cursor).                                                                                    |
| `show_output`                         | Surface output in the editor UI (Windsurf).                                                                                |

## Per-editor coverage

[Section titled “Per-editor coverage”](#per-editor-coverage)

| Event family                                                       | Claude Code |                        Cursor                       |        Copilot       |                 Windsurf                |        Gemini        |
| ------------------------------------------------------------------ | :---------: | :-------------------------------------------------: | :------------------: | :-------------------------------------: | :------------------: |
| `session_start` / `session_end`                                    |     yes     |                         yes                         |          yes         |                    —                    |          yes         |
| `setup`                                                            |     yes     |                          —                          |           —          |                    —                    |           —          |
| `user_prompt_expansion`                                            |     yes     |                          —                          |           —          |                    —                    |           —          |
| `pre_prompt`                                                       |     yes     |                         yes                         |          yes         |                   yes                   |           —          |
| `pre_tool_use` / `post_tool_use`                                   |     yes     |                         yes                         |          yes         | maps to read/write/command/mcp variants |          yes         |
| `post_tool_use_failure`                                            |     yes     |                         yes                         |          yes         |                    —                    |           —          |
| `permission_request` / `permission_denied`                         |     yes     |        `permission_request` via `preToolUse`        |     yes (request)    |                    —                    |           —          |
| `pre_tool_selection`                                               |      —      |                          —                          |           —          |                    —                    |          yes         |
| `pre_model_request` / `post_model_response` / `pre_response_chunk` |      —      | partial (`afterAgentResponse`, `afterAgentThought`) |           —          |                    —                    |          yes         |
| `pre_agent` / `post_agent`                                         |      —      |                          —                          |           —          |                    —                    |          yes         |
| `post_response` / `post_response_with_transcript`                  |      —      |                       partial                       |           —          |      yes (with transcript variant)      |           —          |
| `agent_stop` / `subagent_*`                                        |     yes     |                         yes                         |          yes         |            `agent_stop` only            |           —          |
| `pre_compact` / `post_compact`                                     |     yes     |                    yes (pre only)                   |    yes (pre only)    |                    —                    |  yes (`PreCompress`) |
| Tab hooks                                                          |      —      |                         yes                         |           —          |                    —                    |           —          |
| `notification` / `elicitation*`                                    |     yes     |                          —                          | yes (`notification`) |                    —                    | yes (`Notification`) |
| `error_occurred`                                                   |      —      |                          —                          |          yes         |                    —                    |           —          |
| Worktree / fs / config events                                      |     yes     |                          —                          |           —          |        `post_setup_worktree` only       |           —          |

## Decision output (per editor)

[Section titled “Decision output (per editor)”](#decision-output-per-editor)

aix only writes the hook configuration. Whether a hook *blocks* an action is a contract between your script and the editor. The shapes scripts must print to stdout (or signal via exit code 2) are summarized below.

### Claude Code

[Section titled “Claude Code”](#claude-code)

```json
{
   "decision": "block",
   "reason": "Why blocked",
   "hookSpecificOutput": {
      "hookEventName": "PreToolUse",
      "permissionDecision": "allow|deny|ask|defer",
      "permissionDecisionReason": "Reason",
      "updatedInput": { "field": "value" }
   }
}
```

Exit code 2 also blocks the matching event.

### Cursor

[Section titled “Cursor”](#cursor)

```json
{
   "permission": "allow|deny|ask",
   "user_message": "shown to the user",
   "agent_message": "shown to the agent",
   "updated_input": { "field": "value" }
}
```

Cursor also accepts `failClosed: true` on the hook config to block on hook errors.

### GitHub Copilot CLI

[Section titled “GitHub Copilot CLI”](#github-copilot-cli)

```json
{
   "permissionDecision": "allow|deny|ask",
   "permissionDecisionReason": "Required for deny",
   "modifiedArgs": { "field": "value" }
}
```

`agentStop` and `subagentStop` use `{ "decision": "block|allow", "reason": "..." }`.

### Windsurf Cascade

[Section titled “Windsurf Cascade”](#windsurf-cascade)

Pre-hooks block the action with **exit code 2** and use stderr as the rejection reason. Post-hooks cannot block.

### Gemini CLI

[Section titled “Gemini CLI”](#gemini-cli)

```json
{
   "decision": "deny|allow",
   "reason": "Sent back to the agent on deny",
   "hookSpecificOutput": {
      "additionalContext": "Injected before the response",
      "tool_input": { "field": "value" },
      "tailToolCallRequest": { "name": "another_tool", "args": {} }
   }
}
```

## Editor-native config locations

[Section titled “Editor-native config locations”](#editor-native-config-locations)

| Editor      | Project                                                  | User                                        |
| ----------- | -------------------------------------------------------- | ------------------------------------------- |
| Claude Code | `.claude/settings.json`                                  | `~/.claude/settings.json`                   |
| Cursor      | `.cursor/hooks.json` (with `version: 1`)                 | `~/.cursor/hooks.json`                      |
| Copilot     | `.github/hooks/hooks.json`                               | `~/.config/github-copilot/hooks/hooks.json` |
| Windsurf    | `.windsurf/hooks.json`                                   | `~/.codeium/windsurf/hooks.json`            |
| Gemini      | `.gemini/settings.json` (under `hooks`, merged with MCP) | `~/.gemini/settings.json`                   |

Editors not in the table (Codex, Zed, OpenCode) do not currently support hooks. aix warns when you target them with a hook config.

---

# MCP Servers

> Extend your AI with Model Context Protocol servers.

[Model Context Protocol (MCP)](https://modelcontextprotocol.io) is an open standard that enables AI models to interact with external tools and data sources.

aix provides first-class support for configuring MCP servers and syncing that configuration to any editor that supports MCP (Cursor, GitHub Copilot, Claude Code, Windsurf, Zed, Codex, Gemini, OpenCode).

## Configuring Servers

[Section titled “Configuring Servers”](#configuring-servers)

Define servers in the `mcp` object in `ai.json`. There are two ways to connect to an MCP server:

### 1. Stdio (Local Process)

[Section titled “1. Stdio (Local Process)”](#1-stdio-local-process)

Run a local command (like `npx` or a python script) that speaks MCP over standard input/output.

```json
{
   "mcp": {
      "github": {
         "command": "npx",
         "args": ["-y", "@modelcontextprotocol/server-github"],
         "env": {
            "GITHUB_TOKEN": "${GITHUB_TOKEN}"
         }
      }
   }
}
```

### 2. HTTP (Streamable HTTP)

[Section titled “2. HTTP (Streamable HTTP)”](#2-http-streamable-http)

Connect to a remote MCP server over HTTP.

```json
{
   "mcp": {
      "brave-search": {
         "url": "http://localhost:3000/mcp"
      }
   }
}
```

## Tool & Resource Filtering

[Section titled “Tool & Resource Filtering”](#tool--resource-filtering)

You can restrict which tools and resources an MCP server exposes to the AI.

```json
{
   "mcp": {
      "filesystem": {
         "command": "npx",
         "args": ["-y", "@modelcontextprotocol/server-filesystem", "."],
         "tools": {
            // Only allow reading files, not writing
            "include": ["read_file", "list_directory"],
            "exclude": ["write_file", "edit_file"]
         }
      }
   }
}
```

## Global vs. Project Config

[Section titled “Global vs. Project Config”](#global-vs-project-config)

Some editors (Windsurf and Codex in aix’s current adapter) use global MCP configuration, while others (Cursor, GitHub Copilot, Claude Code, Zed, Gemini, OpenCode) support project-specific config.

aix handles this complexity for you:

* For project-specific editors, it writes to the project config.
* For global-only editors, it **merges** your project’s MCP config into the global config and tracks which project added which server.
* When you remove a server or delete the project, aix automatically cleans up the global config using its state tracking system.

## Finding Servers

[Section titled “Finding Servers”](#finding-servers)

Use `aix search` to browse the official MCP Registry:

```bash
aix search --type mcp
```

This interactive command lets you find servers (like GitHub, Slack, Postgres, Brave Search) and add them to your `ai.json` with one click.

You can also install one MCP server without creating `ai.json`:

```bash
aix install playwright --type mcp --target claude-code --user
aix install https://example.com/mcp --type mcp --name docs --target claude-code --user
```

---

# Prompts

> Reusable slash commands and workflows.

**Prompts** are pre-defined commands or workflows that you can invoke in your editor, typically via a slash command (e.g., `/refactor`, `/review`).

## Usage

[Section titled “Usage”](#usage)

Define prompts in `ai.json`:

```json
{
   "prompts": {
      "review": {
         "description": "Review the selected code for bugs and style issues.",
         "path": "./prompts/review.md"
      },
      "plan": {
         "description": "Generate a step-by-step implementation plan.",
         "argumentHint": "[feature description]",
         "content": "Create a detailed step-by-step plan to implement: "
      }
   }
}
```

## Editor Support

[Section titled “Editor Support”](#editor-support)

aix maps these prompts to the native feature in each editor when one exists:

* **Cursor**: Maps to `.cursor/prompts/` (accessible via `/`).
* **Claude Code**: Maps to `.claude/commands/`.
* **GitHub Copilot**: Project installs map to `.github/prompts/*.prompt.md`, with native prompt-file frontmatter for `name`, `description`, and `argument-hint`. User-scope installs are converted into Copilot skills under `~/.config/github-copilot/skills/`.
* **Windsurf**: Maps to Cascade commands.
* **Codex**: Prompts are deprecated and unsupported natively. aix converts them to instruction-only Agent Skills during install.
* **Gemini**: Maps to project/global TOML files in `.gemini/commands/`.
* **OpenCode**: Maps to markdown command files in `.opencode/commands/` or `~/.config/opencode/commands/`.
* **Zed**: Not supported.

## Prompt Files

[Section titled “Prompt Files”](#prompt-files)

Prompt files are standard markdown. Markdown is preserved as-is.

### Example `prompts/review.md`

[Section titled “Example prompts/review.md”](#example-promptsreviewmd)

```markdown
Review the selected code for:


1. Logic errors
2. Security vulnerabilities
3. Performance bottlenecks


Provide the output in markdown format with code blocks for suggested fixes.
```

## Arguments

[Section titled “Arguments”](#arguments)

Some prompts take arguments. Use the `argumentHint` property to explicitly tell the user what to provide.

```json
"refactor": {
  "argumentHint": "[function_name] [pattern]"
}
```

The content of the prompt will be prefixed to the user’s input.

To install one prompt without creating `ai.json`, use direct install:

```bash
aix install ./prompts/review.md --type prompt --name review --target claude-code --user
```

## Codex conversion

[Section titled “Codex conversion”](#codex-conversion)

Codex uses [Agent Skills](https://developers.openai.com/codex/skills) for reusable workflows. When you install an `ai.json` that contains prompts to Codex, aix converts each prompt into a skill and links it into `.agents/skills/`. The generated skill keeps the prompt content as instructions and includes the prompt description as the skill description.

Name conflicts are resolved in favor of real skills. If `skills.review` and `prompts.review` are both present, aix installs the configured skill as `review` and installs the converted prompt as `prompt-review`. If that name is already taken, aix adds a numeric suffix.

---

# Rules

> Persistent instructions that guide AI behavior.

**Rules** are the most fundamental configuration unit. They are instructions that are “always on” or conditionally applied to guide the AI’s behavior, style, and constraints.

## Default Rules vs. Custom Rules

[Section titled “Default Rules vs. Custom Rules”](#default-rules-vs-custom-rules)

Most editors refer to these as “System Prompts” or “Custom Instructions”. aix unifies them under the concept of **Rules**.

## Usage

[Section titled “Usage”](#usage)

Define rules in `ai.json`:

```json
{
   "rules": {
      "conciseness": {
         "activation": "always",
         "content": "Be concise. Do not explain code unless asked."
      },
      "testing": {
         "activation": "glob",
         "globs": ["**/*.test.ts"],
         "content": "Use Vitest. Prefer 'it' over 'test'."
      }
   }
}
```

## Activation Modes

[Section titled “Activation Modes”](#activation-modes)

| Mode     | Description                                                        | Editor Support                   |
| -------- | ------------------------------------------------------------------ | -------------------------------- |
| `always` | Active for every request.                                          | All editors                      |
| `glob`   | Active only when editing files matching the glob pattern.          | Cursor, GitHub Copilot, Windsurf |
| `auto`   | The AI decides when to activate the rule based on its description. | Cursor, Windsurf (Cascade)       |
| `manual` | Must be explicitly referenced by the user.                         | None (future support)            |

If an editor doesn’t support a specific activation mode (like `glob`), aix falls back to `always` for that editor.

OpenCode uses `AGENTS.md` for rules. aix writes OpenCode rules into a managed section of that file and leaves the rest of the file alone.

Claude Code project rules are written to `.claude/rules/*.md`. User-scope installs write rules to `~/.claude/rules/*.md` and keep `~/.claude/CLAUDE.md` as an aix-managed list of `@rules/...` imports, so personal notes in `CLAUDE.md` stay intact.

## Sources

[Section titled “Sources”](#sources)

Rules can be defined:

* **Inline**: `content: "string"`
* **File**: `path: "./rules/rule.md"`
* **Git**: `git: { url: "...", path: "..." }`
* **npm**: `npm: { package: "...", path: "..." }`

You can install one rule without creating `ai.json`:

```bash
aix install ./rules/typescript.md --type rule --name typescript --target claude-code
```

## Common Use Cases

[Section titled “Common Use Cases”](#common-use-cases)

* **Code Style**: Indentation, naming conventions, preferred libraries.
* **Workflow**: “Always write tests before code”, “Update documentation when changing APIs”.
* **Personality**: “Be Socratic”, “Act as a senior engineer”.

---

# Skills

> Reusable capabilities for your AI agent.

A **Skill** is a package of instructions and context that teaches an AI agent how to perform a specific task or work with a specific technology.

aix follows the [Agent Skills specification](https://agentskills.io) (v1).

## Structure

[Section titled “Structure”](#structure)

A skill is a directory containing a `SKILL.md` file.

```markdown
---
name: react-expert
description: Expert knowledge for React 19 and Next.js 14+
---


# React Expert


You are an expert in React. Follow these principles:


1. Always use functional components.
2. Prefer hooks for state management.
   ...
```

The frontmatter contains metadata, and the markdown body contains the instructions (system prompt context).

## Configuring Skills

[Section titled “Configuring Skills”](#configuring-skills)

Add skills to the `skills` object in `ai.json`:

```json
{
   "skills": {
      "react": "aix-skill-react",
      "tailwindcss": {
         "git": "https://github.com/tailwindlabs/ai-skills",
         "path": "skills/tailwindcss"
      },
      "local-utils": "./skills/utils"
   }
}
```

### Source Types

[Section titled “Source Types”](#source-types)

* **npm**: An installed package name (e.g. `aix-skill-react` or `@scope/skill`).
* **git**: A git URL, shorthand (`github:user/repo`), or repo-path source like `owner/repo/path-to-skill`. To target a subfolder explicitly, use the `path` option in the object form.
* **local**: A relative path to a directory containing a `SKILL.md`.

## Installing Skills

[Section titled “Installing Skills”](#installing-skills)

When you run `aix install`, skills are:

1. Resolved and downloaded (if remote) to `.aix/skills/{name}/`.

2. Symlinked or copied to the appropriate location for each editor:

   * **Cursor**: Symlinked from `.cursor/skills/`.
   * **GitHub Copilot**: Symlinked from `.github/skills/` (native Agent Skills support).
   * **Claude Code**: Symlinked from `.claude/skills/`.
   * **Codex**: Project skills are symlinked from `.agents/skills/`.
   * **OpenCode**: Symlinked from `.opencode/skills/`.
   * **Windsurf**: Symlinked from `.windsurf/skills/`.
   * **Zed**: Skill content added as pointer rules (no native Agent Skills).

`aix add skill` also accepts direct `SKILL.md` paths or blob URLs and normalizes them to the containing skill directory before saving the reference.

When you install with `--user`, the canonical managed copy lives under `~/.aix/skills/{name}/` instead of the project-local `.aix/skills/{name}/`.

To install one skill without creating `ai.json`, use direct install:

```bash
aix install ./skills/review --type skill --target claude-code --user
aix install github:org/aix-skills/review#v1.0.0 --type skill --target cursor
```

## Creating a Skill

[Section titled “Creating a Skill”](#creating-a-skill)

1. Create a directory: `mkdir skills/my-skill`
2. Create `skills/my-skill/SKILL.md`:

```markdown
---
name: my-skill
description: Does x, y, and z
---


# Instructions


...
```

3. Add it to `ai.json`:

```bash
aix add skill ./skills/my-skill
```

---

# ai.json Reference

> Complete reference for every field in the ai.json configuration file.

`ai.json` is the single configuration file that aix uses to sync your AI editor settings. It supports JSONC (comments and trailing commas).

## Lockfiles

[Section titled “Lockfiles”](#lockfiles)

`ai.lock.json` is an optional sibling file for `ai.json`. Create or refresh it with:

```bash
aix validate --lock
```

When `ai.lock.json` exists, aix reads it automatically. If the resolved config digest no longer matches, aix stops and asks you to refresh the lockfile. This catches edits to `ai.json`, inherited configs, local overrides, and resolved entities before aix writes editor files.

The lockfile stores SHA-512 integrity strings and SHA-256 digests for config entities such as skills, rules, prompts, MCP servers, hooks, and editor settings. Hashes prove the content matches the lockfile. They do not prove publisher identity.

## Schema

[Section titled “Schema”](#schema)

Add the `$schema` field for IDE autocompletion and inline validation:

```json
{
   "$schema": "https://x.a1st.dev/schemas/v1/ai.json"
}
```

## Top-level fields

[Section titled “Top-level fields”](#top-level-fields)

| Field     | Type                 | Description                                                                      |
| --------- | -------------------- | -------------------------------------------------------------------------------- |
| `$schema` | `string`             | JSON Schema URL for IDE validation                                               |
| `scope`   | `string`             | `"project"` (default) or `"user"`. Sets whether this is a project or user config |
| `extends` | `string \| string[]` | Inherit from other configs                                                       |
| `skills`  | `object`             | Map of skill names to skill references                                           |
| `mcp`     | `object`             | Map of server names to MCP server configs                                        |
| `rules`   | `object`             | Map of rule names to rule definitions                                            |
| `prompts` | `object`             | Map of prompt names to prompt definitions                                        |
| `agents`  | `object`             | Map of agent names to agent definitions                                          |
| `editors` | `object \| string[]` | Editor targeting and editor-specific settings                                    |
| `hooks`   | `object`             | Lifecycle hooks for AI agent events                                              |
| `aix`     | `object`             | aix tool settings (cache, backups)                                               |

***

## `scope`

[Section titled “scope”](#scope)

Sets whether this config manages project-level or user-level AI configuration. Defaults to `"project"` when omitted.

```json
{
   "scope": "user"
}
```

When `scope` is `"user"`, aix writes to user-level editor config locations (e.g., global MCP settings). When `"project"` (or omitted), aix writes to project-local config files.

***

## `extends`

[Section titled “extends”](#extends)

Inherit from other configurations. Supports a single string or an array. Configs are resolved and deep-merged in order — later entries override earlier ones.

```json
{
   "extends": "github:company/ai-config"
}
```

```json
{
   "extends": ["@company/aix-base", "github:team/project-overrides", "./local-overrides.json"]
}
```

Source types:

* **npm package**: `"@company/aix-config"` or `"aix-config-react"`
* **Git shorthand**: `"github:user/repo"`, `"gitlab:org/repo#v2.0"`
* **URL**: `"https://raw.githubusercontent.com/..."`
* **Local path**: `"./configs/base.json"`

See [Config Inheritance](/configuration/config-inheritance/) for merge semantics.

***

## `skills`

[Section titled “skills”](#skills)

Map of skill names to skill references. Skill names must be lowercase alphanumeric with hyphens (max 64 characters). See [Skills](/concepts/skills/) for the full concept.

### String shorthand

[Section titled “String shorthand”](#string-shorthand)

```json
{
   "skills": {
      "react": "aix-skill-react",
      "custom": "./skills/custom",
      "remote": "github:user/skills#v2.0:skills/react"
   }
}
```

### Object form

[Section titled “Object form”](#object-form)

```json
{
   "skills": {
      "react": {
         "source": {
            "git": "https://github.com/user/repo",
            "ref": "v2.0",
            "path": "skills/react"
         },
         "enabled": true,
         "config": {
            "framework": "nextjs"
         }
      }
   }
}
```

### Disable an inherited skill

[Section titled “Disable an inherited skill”](#disable-an-inherited-skill)

```json
{
   "skills": {
      "inherited-skill": false
   }
}
```

***

## `mcp`

[Section titled “mcp”](#mcp)

Map of server names to MCP server configurations. See [MCP Servers](/concepts/mcp-servers/) for the full concept.

### Stdio transport

[Section titled “Stdio transport”](#stdio-transport)

```json
{
   "mcp": {
      "github": {
         "command": "npx",
         "args": ["-y", "@modelcontextprotocol/server-github"],
         "env": {
            "GITHUB_TOKEN": "${GITHUB_TOKEN}"
         },
         "cwd": ".",
         "shell": false
      }
   }
}
```

| Field     | Type       | Default | Description                                              |
| --------- | ---------- | ------- | -------------------------------------------------------- |
| `command` | `string`   | —       | Command to run                                           |
| `args`    | `string[]` | `[]`    | Command arguments                                        |
| `env`     | `object`   | `{}`    | Environment variables. Use `${VAR}` for shell expansion. |
| `cwd`     | `string`   | `.`     | Working directory                                        |
| `shell`   | `boolean`  | `false` | Run in a shell                                           |

### HTTP transport

[Section titled “HTTP transport”](#http-transport)

```json
{
   "mcp": {
      "remote-server": {
         "url": "https://example.com/mcp",
         "headers": {
            "Authorization": "Bearer ${TOKEN}"
         },
         "timeout": 30000
      }
   }
}
```

| Field            | Type      | Default | Description                        |
| ---------------- | --------- | ------- | ---------------------------------- |
| `url`            | `string`  | —       | MCP endpoint URL (Streamable HTTP) |
| `headers`        | `object`  | `{}`    | Request headers                    |
| `timeout`        | `number`  | —       | Connection timeout in ms           |
| `validateOrigin` | `boolean` | `true`  | Validate server origin             |

### Common options

[Section titled “Common options”](#common-options)

These fields apply to both transport types:

| Field              | Type                 | Default | Description                                                                            |
| ------------------ | -------------------- | ------- | -------------------------------------------------------------------------------------- |
| `enabled`          | `boolean`            | `true`  | Enable/disable the server                                                              |
| `tools`            | `string[] \| object` | —       | Tool access control. Array of allowed tool names, or `{ include: [], exclude: [] }`.   |
| `disabledTools`    | `string[]`           | —       | Tool names to disable                                                                  |
| `resources`        | `string[] \| object` | —       | Resource access control. Array of allowed patterns, or `{ include: [], exclude: [] }`. |
| `autoStart`        | `boolean`            | `true`  | Start with editor                                                                      |
| `restartOnFailure` | `boolean`            | `true`  | Auto-restart on crash                                                                  |
| `maxRestarts`      | `number`             | `3`     | Max restart attempts                                                                   |

### Disable an inherited server

[Section titled “Disable an inherited server”](#disable-an-inherited-server)

```json
{
   "mcp": {
      "inherited-server": false
   }
}
```

***

## `rules`

[Section titled “rules”](#rules)

Map of rule names to rule definitions. See [Rules](/concepts/rules/).

### String shorthand

[Section titled “String shorthand”](#string-shorthand-1)

```json
{
   "rules": {
      "code-style": "./rules/style.md",
      "remote-rule": "github:company/rules#main/typescript.md"
   }
}
```

### Object form

[Section titled “Object form”](#object-form-1)

```json
{
   "rules": {
      "code-style": {
         "activation": "always",
         "content": "Always use TypeScript strict mode."
      },
      "testing": {
         "activation": "glob",
         "globs": ["**/*.test.ts", "**/*.spec.ts"],
         "path": "./rules/testing.md"
      },
      "security": {
         "activation": "auto",
         "description": "Apply when working on authentication or authorization code.",
         "path": "./rules/security.md"
      }
   }
}
```

| Field         | Type       | Default    | Description                                        |
| ------------- | ---------- | ---------- | -------------------------------------------------- |
| `activation`  | `string`   | `"always"` | `"always"`, `"auto"`, `"glob"`, or `"manual"`      |
| `description` | `string`   | —          | When the rule applies (required for `"auto"` mode) |
| `globs`       | `string[]` | —          | File patterns (required for `"glob"` mode)         |
| `content`     | `string`   | —          | Inline rule text                                   |
| `path`        | `string`   | —          | Path to a markdown file                            |
| `git`         | `object`   | —          | `{ url, ref, path }` for git-hosted rules          |
| `npm`         | `object`   | —          | `{ npm, path, version }` for npm-hosted rules      |

One source field (`content`, `path`, `git`, or `npm`) is required.

***

## `prompts`

[Section titled “prompts”](#prompts)

Map of prompt names to prompt definitions. See [Prompts](/concepts/prompts/).

### String shorthand

[Section titled “String shorthand”](#string-shorthand-2)

```json
{
   "prompts": {
      "review": "./prompts/review.md",
      "plan": "./prompts/plan.md"
   }
}
```

### Object form

[Section titled “Object form”](#object-form-2)

```json
{
   "prompts": {
      "review": {
         "description": "Review code changes for quality issues",
         "argumentHint": "[file] [message]",
         "path": "./prompts/review.md"
      }
   }
}
```

| Field          | Type     | Description                                     |
| -------------- | -------- | ----------------------------------------------- |
| `description`  | `string` | Shown in the editor’s command picker            |
| `argumentHint` | `string` | Hint for arguments (e.g., `"[file] [message]"`) |
| `content`      | `string` | Inline prompt text                              |
| `path`         | `string` | Path to a markdown file                         |
| `git`          | `object` | `{ url, ref, path }` for git-hosted prompts     |
| `npm`          | `object` | `{ npm, path, version }` for npm-hosted prompts |

***

## `agents`

[Section titled “agents”](#agents)

Map of specialized agent names to agent definitions. See [Agents](/concepts/agents/).

### String shorthand

[Section titled “String shorthand”](#string-shorthand-3)

```json
{
   "agents": {
      "code-reviewer": "./agents/code-reviewer.md"
   }
}
```

### Object form

[Section titled “Object form”](#object-form-3)

```json
{
   "agents": {
      "code-reviewer": {
         "description": "Review code changes",
         "mode": "subagent",
         "model": "sonnet",
         "tools": ["Read", "Grep"],
         "permissions": {
            "edit": "deny"
         },
         "content": "Review the current diff."
      }
   }
}
```

| Field         | Type     | Description                                                     |
| ------------- | -------- | --------------------------------------------------------------- |
| `description` | `string` | When the editor should use the agent                            |
| `mode`        | `string` | `"primary"` or `"subagent"`                                     |
| `model`       | `string` | Editor model alias or model ID                                  |
| `tools`       | `array`  | Tool names available to the agent                               |
| `permissions` | `object` | Portable `allow`, `ask`, or `deny` capability policies          |
| `mcp`         | `object` | MCP servers available to this agent when supported              |
| `content`     | `string` | Inline agent instructions                                       |
| `path`        | `string` | Path to a markdown file                                         |
| `git`         | `object` | `{ url, ref, path }` for git-hosted agents                      |
| `npm`         | `object` | `{ npm, path, version }` for npm-hosted agents                  |
| `editor`      | `object` | Editor-specific fields keyed by editor ID for round-trip safety |

***

## `editors`

[Section titled “editors”](#editors)

Configure which editors to install to and provide editor-specific settings.

### Array shorthand

[Section titled “Array shorthand”](#array-shorthand)

```json
{
   "editors": ["cursor", "copilot", "claude-code", "opencode"]
}
```

### Object form

[Section titled “Object form”](#object-form-4)

```json
{
   "editors": {
      "cursor": {
         "enabled": true,
         "rules": {
            "cursor-only": {
               "content": "Cursor-specific instructions here"
            }
         },
         "aiSettings": {}
      },
      "windsurf": {
         "enabled": true,
         "cascadeSettings": {}
      },
      "claude-code": {
         "enabled": true,
         "permissions": {}
      },
      "opencode": {
         "enabled": true
      }
   }
}
```

If `editors` is omitted, aix auto-detects installed editors at install time. See [Editor Configuration](/configuration/editor-configuration/).

***

## `hooks`

[Section titled “hooks”](#hooks)

Lifecycle hooks for AI agent events. See [Hooks](/concepts/hooks/).

```json
{
   "hooks": {
      "session_start": [
         {
            "matcher": ".*",
            "hooks": [
               {
                  "command": "echo 'Session started'",
                  "timeout": 5,
                  "show_output": true
               }
            ]
         }
      ]
   }
}
```

***

## `aix`

[Section titled “aix”](#aix)

Settings for the aix tool itself. These don’t affect AI editor behavior.

```json
{
   "aix": {
      "cache": {
         "maxBackups": 5,
         "maxBackupAgeDays": 30,
         "maxCacheAgeDays": 7
      }
   }
}
```

| Field                    | Type     | Default | Range | Description                   |
| ------------------------ | -------- | ------- | ----- | ----------------------------- |
| `cache.maxBackups`       | `number` | `5`     | 1–100 | Max backup files to keep      |
| `cache.maxBackupAgeDays` | `number` | `30`    | 1–365 | Max backup age before cleanup |
| `cache.maxCacheAgeDays`  | `number` | `7`     | 1–365 | Max cache age before cleanup  |

---

# ai.local.json

> Use local configuration overrides for secrets and developer-specific settings.

`ai.local.json` is a companion file to `ai.json` designed for configuration that should **not** be shared with your team or committed to version control.

## Usage

[Section titled “Usage”](#usage)

Create a file named `ai.local.json` in the same directory as your `ai.json`:

```json
{
   "mcp": {
      "github": {
         "env": {
            "GITHUB_TOKEN": "ghp_my_secret_token"
         }
      }
   }
}
```

When you run `aix install`, settings in `ai.local.json` are merged **on top** of `ai.json`.

## Best Practices

[Section titled “Best Practices”](#best-practices)

### 1. Ignore it in git

[Section titled “1. Ignore it in git”](#1-ignore-it-in-git)

Always add `ai.local.json` to your `.gitignore`:

.gitignore

```text
ai.local.json
.aix/
```

### 2. Store secrets here

[Section titled “2. Store secrets here”](#2-store-secrets-here)

Do not put API keys or tokens in `ai.json`. Instead, reference environment variables (`${VAR}`) in `ai.json` and set them in your shell, OR define them directly in `ai.local.json`.

### 3. Developer preferences

[Section titled “3. Developer preferences”](#3-developer-preferences)

Use `ai.local.json` to enable or disable tools locally without affecting teammates.

**Example: turning off a noisy linter rule locally**

ai.local.json

```json
{
   "rules": {
      "strict-linting": false
   }
}
```

## Restrictions

[Section titled “Restrictions”](#restrictions)

Unlike the main `ai.json`, `ai.local.json` does **not** support the `extends` field. It is designed to be a flat patch file, not part of a complex inheritance chain.

## CLI Support

[Section titled “CLI Support”](#cli-support)

Most aix commands support a `--local` (or `-l`) flag to operate on the local config instead of the shared one.

```bash
# Add an MCP server to local config only
aix add mcp github --local


# Remove a rule from local config only
aix remove rule strict-linting --local
```

---

# Config Inheritance

> Share and layer configurations using the extends field.

aix allows you to inherit configuration from other sources using the `extends` field in `ai.json`. This enables organizations to maintain shared “base” configurations (with standard rules, skills, and MCP servers) while allowing individual projects to add their own.

## Usage

[Section titled “Usage”](#usage)

The `extends` field accepts a string or an array of strings.

```json
{
   "extends": "github:my-org/ai-standards"
}
```

Multiple sources are supported. They are processed in order, with later configurations overriding earlier ones:

```json
{
   "extends": [
      // 1. Base company standards
      "github:company/ai-base",


      // 2. Team specific overrides
      "github:team-platform/ai-config",


      // 3. Local file mixin
      "./configs/react-project.json"
   ]
}
```

The final configuration is the result of merging all extended configs into your project’s `ai.json`.

## Source Types

[Section titled “Source Types”](#source-types)

aix supports extending from:

### npm packages

[Section titled “npm packages”](#npm-packages)

```json
{ "extends": "@company/aix-config" }
```

The package must export an `ai.json` (or have one in its root).

### Git repositories

[Section titled “Git repositories”](#git-repositories)

Use the shorthand syntax `provider:user/repo`:

```json
{ "extends": "github:company/repo" }
```

You can target a specific branch, tag, or commit hash:

```json
{ "extends": "github:company/repo#v2.0.0" }
```

If the config file is not at the root of the repo, use the `path` query param (not supported in shorthand yet, so use full URL or ensure it’s at root/`ai.json` for now).

### URLs

[Section titled “URLs”](#urls)

Direct HTTP/HTTPS URLs to a JSON file:

```json
{ "extends": "https://raw.githubusercontent.com/user/repo/main/ai.json" }
```

### Local paths

[Section titled “Local paths”](#local-paths)

Relative paths to other JSON files:

```json
{ "extends": "../shared/ai.json" }
```

## Merge Logic

[Section titled “Merge Logic”](#merge-logic)

When merging configurations:

1. **Object maps**: `skills`, `mcp`, `rules`, and `prompts` are merged by key. Keys in your `ai.json` overwrite keys from `extends`.
2. **Editors**: Normalized to object form and deep-merged. Remote editor settings are merged into local ones per editor key.
3. **Metadata**: `$schema` and `extends` from the remote config win.
4. **Disabling**: You can disable an inherited item by setting it to `false`.
5. **Not inherited**: `hooks` and `aix` settings are not inherited from extended configs.

**Example: Disabling an inherited rule**

Base config (`github:company/base`):

```json
{
   "rules": {
      "always-add-tests": { "content": "..." }
   }
}
```

Your config:

```json
{
   "extends": "github:company/base",
   "rules": {
      "always-add-tests": false
   }
}
```

## Resolution Process

[Section titled “Resolution Process”](#resolution-process)

1. references in `extends` are resolved and downloaded (cached in `.aix/cache`).
2. Configs are loaded in order.
3. Recursive `extends` are resolved (a config can extend another config).
4. All configs are merged into a single “resolved” configuration.
5. Your local `ai.json` is applied last.
6. `ai.local.json` (if present) is applied on top.

To see the final result of this process, run:

```bash
aix config show --resolved
```

---

# Editor Configuration

> Configure target editors and editor-specific settings.

By default, `aix install` detects all supported editors installed on your system and syncs configuration to them. You can control this behavior and pass editor-specific settings using the `editors` field.

## Limiting Installation

[Section titled “Limiting Installation”](#limiting-installation)

To only install to specific editors, provide an array of strings:

```json
{
   "editors": ["cursor", "copilot", "opencode"]
}
```

Or use the object form:

```json
{
   "editors": {
      "cursor": { "enabled": true },
      "copilot": { "enabled": true },
      "opencode": { "enabled": true },
      "windsurf": { "enabled": false }
   }
}
```

## Editor-Specific Settings

[Section titled “Editor-Specific Settings”](#editor-specific-settings)

The object form allows you to pass additional configuration to specific editors.

### Windsurf

[Section titled “Windsurf”](#windsurf)

Windsurf (by Codeium) supports “Cascade” settings.

```json
{
   "editors": {
      "windsurf": {
         "enabled": true,
         "cascadeSettings": {
            "mcp": {
               "globalEnabled": true
            }
         }
      }
   }
}
```

### Cursor

[Section titled “Cursor”](#cursor)

Cursor has its own AI settings block.

```json
{
   "editors": {
      "cursor": {
         "enabled": true,
         "aiSettings": {
            // Cursor specific settings
         }
      }
   }
}
```

### Claude Code

[Section titled “Claude Code”](#claude-code)

Configure permissions for the Claude Code CLI tool.

```json
{
   "editors": {
      "claude-code": {
         "enabled": true,
         "permissions": {
            "allow-file-access": true
         }
      }
   }
}
```

### OpenCode

[Section titled “OpenCode”](#opencode)

OpenCode currently uses the shared editor config shape. Target it with `enabled` and optional OpenCode-only rules:

```json
{
   "editors": {
      "opencode": {
         "enabled": true,
         "rules": {
            "opencode-context": {
               "content": "Prefer OpenCode commands when a reusable workflow exists."
            }
         }
      }
   }
}
```

## Editor-Specific Rules

[Section titled “Editor-Specific Rules”](#editor-specific-rules)

Sometimes you need to give instructions to one specific AI model but not others. You can define rules nested under the editor config:

```json
{
   "editors": {
      "cursor": {
         "rules": {
            "cursor-shortcuts": {
               "content": "Use cmd+k for inline edits..."
            }
         }
      }
   }
}
```

Rules defined here will **only** be written to that editor’s configuration.

---

# Editor changelog

> Research notes for editor release changes that affect aix implementation and user workflows.

This page is generated from markdown notes in `docs/editor-research/`. Each note records the editor version checked, the research timestamp, source links, and what aix needs to do about the change.

**17** version notes

**82** tracked changes

**8** supported editors

Editor All editors (all) aix status All statuses (all)

No editor research notes match those filters.

Sources: [code.claude.com](https://code.claude.com/docs/en/changelog) , [code.claude.com](https://code.claude.com/docs/en/settings) , [code.claude.com](https://code.claude.com/docs/en/hooks)

* Claude Code 2.1.163 added managed \`requiredMinimumVersion\` and

  Needs follow-up

  needs follow-up only if aix starts writing Claude Code managed

* Claude Code 2.1.163 lets \`Stop\` and \`SubagentStop\` hooks return

  Needs review

  no config schema change needed. aix writes hook definitions, not runtime

* Claude Code 2.1.160 added more prompts before editing shell startup files and build

  Needs review

  no generated config change needed. This is Claude Code runtime safety

* Claude Code 2.1.154 introduced dynamic workflows and \`/workflows\`.

  Needs review

  no current implementation change. aix does not model Claude workflow

* Claude Code 2.1.154 added plugin \`defaultEnabled: false\`.

  Needs review

  no current implementation change. aix does not generate Claude Code

* Claude Code 2.1.154 changed unapproved \`.mcp.json\` servers to show as pending

  No repo change

  no format change needed. Existing MCP output remains the same, but

* Claude Code 2.1.154 sends \`CLAUDE\_CODE\_SESSION\_ID\` and \`CLAUDECODE=1\` to stdio MCP

  Needs review

  no config change needed. This affects runtime server environments, not

Sources: [github.com](https://github.com/openai/codex/releases) , [github.com](https://github.com/openai/codex/blob/main/docs/config.md) , [developers.openai.com](https://developers.openai.com/codex/changelog)

* Codex 0.135.0 added named permission profiles to \`/permissions\`.

  Needs follow-up

  needs follow-up only if aix adds a portable permissions feature. Current

* Codex 0.135.0 added richer \`codex doctor\` diagnostics for environment, Git, terminal,

  No repo change

  no implementation change needed. This improves diagnostics for users

* Codex 0.135.0 made \`/status\` show remote connection details and server version.

  Needs review

  no config change needed.

* Codex 0.135.0 added non-interactive \`install.sh\` and \`install.ps1\` behavior through

  Needs review

  no current implementation change. aix does not install Codex itself.

* The current GitHub release page also shows 0.136.0 alpha builds after 0.135.0.

  Needs review

  no alpha release note was used for implementation planning. Re-check

Sources: [raw.githubusercontent.com](https://raw.githubusercontent.com/github/copilot-cli/main/changelog.md) , [docs.github.com](https://docs.github.com/en/copilot/reference/custom-agents-configuration) , [docs.github.com](https://docs.github.com/en/copilot/reference/copilot-cli-reference/cli-config-dir-reference)

* Copilot CLI 1.0.60 added \`builtInAgents.rubberDuckAutoInvoke\`.

  Needs review

  no current implementation change. aix does not manage Copilot runtime

* Copilot CLI 1.0.60 added LSP server config support for \`bash\`, \`powershell\`, and \`cwd\`.

  Needs review

  no current implementation change. aix does not generate Copilot LSP

* Copilot CLI 1.0.60 changed Windows executable discovery so bare command names no

  No repo change

  no format change needed. Generated hook and MCP commands should already

* Copilot CLI 1.0.60 added \`-r\` as shorthand for \`--resume\`.

  No repo change

  no implementation change needed.

* Copilot CLI 1.0.54 added \`deferred-tool-loading\` frontmatter for custom agents.

  Needs follow-up

  needs follow-up if aix should expose this field in portable agent

* Copilot CLI 1.0.54 migrates legacy nested MCP OAuth keys to \`oauthClientId\` and

  Needs review

  inspect before implementation if aix starts emitting Copilot OAuth MCP

* Copilot CLI 1.0.53 fixed \`/skills\` picker persistence with \`--config-dir\`.

  Needs review

  no generated config change needed.

* Copilot CLI 1.0.51 added \`preMcpToolCall\` hooks and lets \`postToolUse\` hooks inject

  Needs follow-up

  needs follow-up if Copilot hook docs expose stable config for

Sources: [cursor.com](https://cursor.com/changelog) , [docs.cursor.com](https://docs.cursor.com/)

* Cursor 3.7 added Design Mode improvements in the Cursor browser, including

  Needs review

  no generated config change needed. This is editor UI behavior, not a

* Cursor 3.7 added Cursor SDK support for custom metadata stores, custom local tools,

  Needs review

  no current implementation change. These SDK surfaces are separate from

* Cursor 3.7 added a context usage report and canvas Design Mode changes.

  Needs review

  no generated config change needed.

* Cursor 3.7 SDK releases changed run metadata and local shell packaging behavior.

  Needs review

  no current implementation change. Re-check only if aix starts generating

Sources: [github.com](https://github.com/google-gemini/gemini-cli/releases) , [github.com](https://github.com/google-gemini/gemini-cli/blob/main/docs/changelogs/index.md) , [github.com](https://github.com/google-gemini/gemini-cli/tree/main/docs)

* Gemini CLI 0.45.0 includes a "context simplification" change in its release notes.

  Needs review

  no generated config change identified from the published release note.

* Gemini CLI 0.45.0 includes a fix that prevents \`mcp list\` blacklist bypass.

  Needs review

  no config shape change needed. This affects runtime MCP behavior after

* Gemini CLI 0.45.0 includes routing and session history fixes.

  No repo change

  no implementation change needed for aix output.

* The GitHub releases page also shows 0.46.0 preview builds after 0.45.0.

  Needs review

  no preview release note was used for implementation planning. Re-check

Sources: [github.com](https://github.com/anomalyco/opencode/releases) , [opencode.ai](https://opencode.ai/docs/config/) , [opencode.ai](https://opencode.ai/docs/agents/)

* OpenCode 1.16.0 added skill discovery and file-based agent loading.

  Needs follow-up

  needs follow-up. aix already writes OpenCode skills under

* OpenCode 1.16.0 added managed workspace cloning that keeps dirty and untracked files.

  Needs review

  no generated config change needed.

* OpenCode 1.16.0 added moving sessions between workspaces and directories.

  Needs review

  no generated config change needed.

* OpenCode 1.16.0 fixed Windows path normalization in migrated storage.

  Needs review

  no direct config change needed, but keep Windows fixture coverage for

* OpenCode 1.16.0 fixed the GitHub extension so it refuses to commit without an existing

  Needs review

  no generated config change needed.

Sources: [docs.devin.ai](https://docs.devin.ai/desktop/changelog) , [windsurf.com](https://windsurf.com/changelog)

* Windsurf is now Devin Desktop as of the 3.0.12 release note.

  Needs follow-up

  needs follow-up for naming and detection only if the rebrand changes

* Devin Desktop 3.0.21 added a command to rerun migration from Windsurf.

  Needs review

  no generated config change needed.

* Devin Desktop 2.3.15 increased remote server startup timeout.

  Needs review

  no generated config change needed.

* Devin Desktop 2.3.15 updated the bundled Devin Local agent. The note says Devin Local

  Needs follow-up

  needs follow-up for hook behavior only if the Devin Desktop hook docs

Sources: [zed.dev](https://zed.dev/releases/stable) , [zed.dev](https://zed.dev/docs)

* Zed 1.5.3 fixed commit message generation so it respects instructions from global

  Needs review

  no generated config change needed. This confirms that the Zed 1.4.2

* Zed 1.5.3 fixed deprecated Rules being automatically included in new agent requests.

  Needs review

  no generated config change needed. aix already moved Zed skills to

* Zed 1.5.3 fixed global skill edits appearing without a file path in change summaries.

  Needs review

  no generated config change needed. This affects runtime display after

* Zed 1.5.3 fixed UTF-8 parsing issues when loading skill frontmatter with multi-codepoint

  Needs review

  no generated config change needed. aix writes skill frontmatter as plain

* Zed 1.4.4 and 1.4.3 only show Copilot-chat model dropdown fixes in the stable release

  Needs review

  no generated config change needed.

Sources: [zed.dev](https://zed.dev/releases/stable) , [github.com](https://github.com/zed-industries/zed/pull/56456) , [github.com](https://github.com/zed-industries/zed/blob/main/assets/prompts/SKILL.md)

* Zed 1.4.2 introduced native Agent Skills, replacing the Rules Library.

  Needs review

  switch from \`PointerSkillsStrategy\` to \`NativeSkillsStrategy\` with

* Zed 1.4.2 removed the Rules Library UI entirely.

  Needs review

  pointer rules are no longer the right approach for skills. The \`PointerSkillsStrategy\`

* Zed 1.4.2 added \`\~/.config/zed/AGENTS.md\` as the user-scope global rules file.

  Needs review

  \`ZedRulesStrategy.getGlobalRulesPath()\` now returns \`.config/zed/AGENTS.md\`. User-scope

Sources: [code.claude.com](https://code.claude.com/docs/en/changelog) , [code.claude.com](https://code.claude.com/docs/en/hooks)

* Claude Code 2.1.147 added the \`Workflow\` tool behind \`CLAUDE\_CODE\_WORKFLOWS=1\`.

  Needs follow-up

  needs follow-up only if aix decides to model Claude workflow files or workflow-specific permissions. Current aix support is focused on rules, prompts, MCP, skills, agents, and hooks.

* Claude Code 2.1.145 added \`background\_tasks\` and \`session\_crons\` fields to \`Stop\` and \`SubagentStop\` hook input.

  No repo change

  no schema change needed for hook input payloads because aix stores hook config, not runtime payload types. Docs should mention these fields if the hook guide starts documenting event payload examples.

* Claude Code 2.1.147 fixed hook \`if\` conditions such as \`PowerShell(git push\*)\`.

  Already handled

  already exposes the Claude Code \`if\` action field in \`packages/schema/src/hooks.ts\` and passes it through in \`packages/core/src/editors/strategies/claude-code/hooks.ts\`.

* Claude Code 2.1.147 fixed MCP pagination for servers, resources, templates, and prompts.

  Needs review

  no install-format change needed. This affects runtime Claude Code behavior after aix writes MCP config.

* Claude Code 2.1.147 renamed \`/simplify\` to \`/code-review\`.

  Needs review

  no aix implementation change. aix prompt and skill names are user-defined and do not depend on Claude Code built-in slash command names.

Sources: [developers.openai.com](https://developers.openai.com/codex/changelog) , [github.com](https://github.com/openai/codex/releases)

* Codex 0.133.0 enables goals by default and stores goal progress across active turns.

  No repo change

  no current code change. aix does not model Codex goal storage yet.

* Codex 0.133.0 expanded permission profiles with list APIs, inheritance, managed \`requirements.toml\` support, runtime refresh behavior, and stronger Windows sandbox integration.

  Needs follow-up

  needs follow-up research before implementation. Current aix Codex support focuses on AGENTS.md, MCP, skills, prompts-as-skills, and rules; permission profile files are not modeled in \`ai.json\`.

* Codex 0.133.0 made plugin discovery easier to inspect and added visible installed versions and marketplace roots.

  No repo change

  no current code change. aix does not install Codex plugins.

* Codex 0.133.0 added more extension lifecycle events, including subagent start/stop, tool execution, turn metadata, and async approval/turn processing.

  Needs follow-up

  needs follow-up if Codex exposes these events through a stable config file. \`packages/schema/src/editor-support.ts\` currently marks Codex hooks as unsupported.

* Codex 0.133.0 made AGENTS instruction loading more reliable, including local global reads and invalid UTF-8 warnings.

  No repo change

  no format change needed. aix already treats \`AGENTS.md\` as the Codex instruction surface.

Sources: [raw.githubusercontent.com](https://raw.githubusercontent.com/github/copilot-cli/main/changelog.md) , [docs.github.com](https://docs.github.com/en/copilot/reference/custom-agents-configuration)

* The current npm package version is 1.0.51. The public Copilot CLI changelog inspected during this run listed detailed notes through 1.0.49.

  Needs review

  use 1.0.51 as the checked package version, but compare future work against 1.0.49 release-note details unless GitHub publishes missing 1.0.50 and 1.0.51 notes.

* Copilot CLI 1.0.49 says repo hooks in \`.github/hooks/\` load in prompt mode when the folder is already trusted.

  Already handled

  already aligned. \`packages/core/src/editors/strategies/copilot/hooks.ts\` writes project hooks under \`.github/hooks/hooks.json\`.

* Copilot CLI 1.0.49 accepts MCP server configs with no \`args\` field and treats it as an empty args list.

  No repo change

  no code change needed unless aix validation rejects missing args for Copilot MCP output. Existing MCP normalization should be checked before changing code.

* Copilot CLI 1.0.49 reports MCP stdio servers as \`stdio\` instead of \`local\`.

  Needs follow-up

  needs follow-up only if generated Copilot MCP config still emits a deprecated local type. Inspect \`packages/core/src/editors/strategies/copilot/mcp.ts\` before changing.

* GitHub custom agents support \`tools\`, \`mcp-servers\`, \`metadata\`, \`disable-model-invocation\`, and \`user-invocable\`; \`argument-hint\` and \`handoffs\` are ignored by the cloud agent.

  Needs follow-up

  needs follow-up if aix expands Copilot agent support beyond the currently documented fields.

Sources: [cursor.com](https://cursor.com/changelog) , [prod.cursor.com](https://prod.cursor.com/changelog/2-4)

* Cursor 3.5 added Automations to the Agents Window and supports automations with multiple repositories or no repository.

  No repo change

  no current code change. aix does not model Cursor Automations yet.

* Cursor 3.4 improved cloud-agent environment configuration as code, including Dockerfile-based setup, build secrets, environment version history, and scoped secrets.

  No repo change

  no current code change. These settings are not part of the local editor config files aix writes today.

* Cursor 2.4 introduced Agent Skills in the editor and CLI with \`SKILL.md\` files.

  Already handled

  already aligned. \`packages/schema/src/editor-support.ts\` lists native Cursor skills, and Cursor skill installs are handled through the editor strategy layer.

* Cursor 2.4 moved MCP server definitions and tools into JSON files under \`.cursor\`, loaded only when needed.

  Already handled

  already aligned for project MCP output at \`.cursor/mcp.json\`.

* Cursor 2.4 expanded hooks, including stop hooks, \`beforeSubmitPrompt\`, \`PreToolUse\`, \`PostToolUse\`, team and MDM hooks in CLI, and Claude Code hook compatibility.

  Already handled

  already partly aligned. \`packages/core/src/editors/strategies/cursor/hooks.ts\` maps the supported aix hook events to Cursor native names; MDM/team cloud hook config is not modeled.

Sources: [github.com](https://github.com/google-gemini/gemini-cli/blob/main/docs/changelogs/index.md)

* Gemini CLI 0.42.0 introduced an Auto Memory Inbox with a canonical-patch contract for skill management.

  Needs follow-up

  needs follow-up only if Gemini documents stable memory files or skill patch files that aix should manage. Current aix Gemini support writes rules, prompts, MCP, and hooks.

* Gemini CLI 0.40.0 introduced MCP resource tools and a four-tier memory management system.

  Needs review

  no current MCP config change found in this run. If resource tool settings become user-configurable, update the Gemini MCP strategy.

* Gemini CLI 0.24.0 and later release notes describe Agent Skills support, \`/skills reload\`, and \`/skills install/uninstall\`.

  Needs follow-up

  needs follow-up. \`packages/schema/src/editor-support.ts\` should be checked to confirm whether Gemini skills are intentionally unsupported or now should be native.

* Gemini CLI hooks are configured in \`.gemini/settings.json\`.

  Already handled

  already aligned. \`packages/core/src/editors/strategies/gemini/hooks.ts\` writes hooks into \`.gemini/settings.json\`.

Sources: [github.com](https://github.com/anomalyco/opencode/releases) , [opencode.ai](https://opencode.ai/docs/config/) , [opencode.ai](https://opencode.ai/docs/agents/)

* The current npm package version is 1.15.7. The GitHub releases page inspected during this run showed 1.15.6 as the latest detailed release note.

  Needs review

  use 1.15.7 as the checked package version, but compare release-note details against 1.15.6 until the detailed 1.15.7 notes are visible.

* OpenCode 1.15.6 fixed agent and command name resolution from relative config paths.

  Needs review

  already likely aligned. aix writes OpenCode \`instructions\` and \`command\` config using project-relative paths; keep this note for regression testing.

* OpenCode config supports JSON and JSONC, merged global/project/remote config, \`instructions\`, \`command\`, \`mcp\`, plugins, permissions, agents, and managed settings.

  Already handled

  already partly aligned. aix supports \`opencode.json\` and \`opencode.jsonc\`, imports config-defined \`instructions\` and \`command\` prompts, writes MCP under top-level \`mcp\`, and treats hooks as unsupported.

* OpenCode agent docs mark \`tools\` as deprecated in favor of permissions.

  Needs follow-up

  needs follow-up if aix emits OpenCode agent files with \`tools\`. Current OpenCode support should prefer permission-oriented fields if agent output expands.

Sources: [windsurf.com](https://windsurf.com/changelog)

* Windsurf 2.3.9 fixed terminal processing performance, restored conversation sharing, and repaired WSL path resolution for the Devin local agent.

  No repo change

  no config-format change found for aix.

* Windsurf 2.2.17 included MCP server bug fixes.

  No repo change

  no schema change found in this run. Keep existing Windsurf MCP output unless a specific MCP config key changes.

* Windsurf 1.9577.24 added support for loading \`SKILL.md\` files from \`.windsurf/skills/\`.

  Already handled

  already aligned. \`packages/schema/src/editor-support.ts\` documents native Windsurf skills and the strategy layer handles \`.windsurf/skills/\`.

* Windsurf 1.9552.21 added support for reading skills from \`.agents/skills\`, added \`rules\_applied\` to the \`post\_cascade\_response\` hook, and fixed \`post\_write\_code\` hooks for all code editing tool formats.

  Needs review

  \`.agents/skills\` compatibility is documented. Runtime hook payload fields such as \`rules\_applied\` do not require a schema change unless aix starts documenting event payload examples.

* Windsurf 1.9566.9 added \`POST\_CASCADE\_RESPONSE\_WITH\_TRANSCRIPT\`, team hook visibility, and MCP OAuth improvements.

  Already handled

  already partly aligned. \`packages/core/src/editors/strategies/windsurf/hooks.ts\` maps \`post\_response\_with\_transcript\` to \`post\_cascade\_response\_with\_transcript\`.

Sources: [zed.dev](https://zed.dev/releases/stable)

* Zed 1.3.5 added terminal threads in the sidebar and Agent Panel.

  No repo change

  no config-format change found for aix.

* Zed 1.3.5 added a \`subagent\_model\` setting for spawned subagents.

  Needs follow-up

  needs follow-up only if aix adds Zed agent/subagent config support. Current Zed support focuses on rules, prompts, MCP, and skill pointer rules.

* Zed 1.3.5 added user confirmation before tools modify \`.agents/skills/\` or \`\~/.agents/skills/\`.

  No repo change

  no code change needed. This protects skills installed by aix or other agents after they exist on disk.

* Zed 1.3.5 added inline image and Mermaid rendering in the agent.

  No repo change

  no config-format change found for aix.

---

# Claude Code support details

> How aix maps rules, prompts, MCP, skills, hooks, and compatibility surfaces for Claude Code.

Native rules, prompts, skills, MCP, and the broadest hook surface in the matrix.

Claude Code is the easiest target when you need native hooks and native prompts together.

Start on [the full support matrix](/editors/supported-editors/) when you need to compare every editor at once. Use this page when you want the exact terms, support details, and project/user targets for Claude Code.

Related aix concepts: [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## Editor-specific notes

* Claude Code supports more lifecycle hook events than any other supported editor.
* Its native repo instruction file is `CLAUDE.md`, not `AGENTS.md`.

## Feature details

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

### Rules [Learn the concept](/concepts/rules/)

Markdown rule files.

Claude Code calls this **Rules**

aix support Native

* Project

  Editor Supported aix Native

  Path `.claude/rules/*.md`

* User

  Editor Supported aix Native

  Path `~/.claude/CLAUDE.md`

- User scope is a single global memory file instead of per-rule files.

### Prompts [Learn the concept](/concepts/prompts/)

Markdown command files with YAML frontmatter.

Claude Code calls this **Commands**

aix support Native

* Project

  Editor Supported aix Native

  Path `.claude/commands/*.md`

* User

  Editor Supported aix Native

  Path `~/.claude/commands/*.md`

**Supported metadata:** `description` , `argument-hint`

### MCP [Learn the concept](/concepts/mcp-servers/)

JSON `mcpServers` configuration.

Claude Code calls this **MCP servers**

aix support Native

* Project

  Editor Supported aix Native

  Path `.mcp.json`

* User

  Editor Supported aix Native

  Path `~/.claude.json`

### Skills [Learn the concept](/concepts/skills/)

Symlinked native skill directories backed by `.aix/skills/`.

Claude Code calls this **Skills**

aix support Native

* Project

  Editor Supported aix Native

  Path `.claude/skills/{name}/`

* User

  Editor Supported aix Native

  Path `~/.claude/skills/{name}/`

### Agents

Markdown subagent files with YAML frontmatter.

Claude Code calls this **Subagents**

aix support Native

* Project

  Editor Supported aix Native

  Path `.claude/agents/*.md`

* User

  Editor Supported aix Native

  Path `~/.claude/agents/*.md`

**Supported metadata:** `description` , `mode` , `model` , `tools` , `permissions` , `mcp` , `editor.claude-code`

### Hooks [Learn the concept](/concepts/hooks/)

JSON hooks with PascalCase event names, matcher routing, and `command` / `http` / `mcp_tool` / `prompt` / `agent` action types.

Claude Code calls this **Hooks**

aix support Native

* Project

  Editor Supported aix Native

  Path `.claude/settings.json`

* User

  Editor Supported aix Native

  Path `~/.claude/settings.json`

**Supported metadata:** `ConfigChange` , `CwdChanged` , `Elicitation` , `ElicitationResult` , `FileChanged` , `InstructionsLoaded` , `Notification` , `PermissionDenied` , `PermissionRequest` , `PostCompact` , `PostToolBatch` , `PostToolUse` , `PostToolUseFailure` , `PreCompact` , `PreToolUse` , `SessionEnd` , `SessionStart` , `Setup` , `Stop` , `SubagentStart` , `SubagentStop` , `TaskCompleted` , `TaskCreated` , `TeammateIdle` , `UserPromptExpansion` , `UserPromptSubmit` , `WorktreeCreate` , `WorktreeRemove`

* Command hooks surface `async`, `asyncRewake`, `shell`, `if`, `statusMessage`, and `once`.
* Non-command hook types (`http`, `mcp_tool`, `prompt`, `agent`) are translated by aix.

### AGENTS.md

Claude Code uses `CLAUDE.md` instead of AGENTS.md.

Claude Code calls this **CLAUDE.md**

aix support No support

* Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Use `CLAUDE.md` for repository instructions.

* User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Use `~/.claude/CLAUDE.md` for home-scoped instructions.

### .agents/skills

Claude Code uses native `.claude/skills/` directories instead of `.agents/skills/`.

Claude Code calls this **.claude/skills**

aix support No support

* Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Use `.claude/skills/` instead of `.agents/skills/`.

* User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Use `~/.claude/skills/` instead of `.agents/skills/`.

## Related guides

* [Claude Code to Cursor](/editors/migrations/how-to-migrate-from-claude-code-to-cursor/)
* [Cursor to Claude Code](/editors/migrations/how-to-migrate-from-cursor-to-claude-code/)
* [All migration guides that start from Claude Code](/editors/migrations/#claude-code)

---

# Codex support details

> How aix maps rules, prompts, MCP, skills, hooks, and compatibility surfaces for Codex.

Rules, skills, and hooks are native, prompts become skills, and aix still treats MCP as global-only.

Codex is strongest when AGENTS.md and Agent Skills are the destination format you want.

Start on [the full support matrix](/editors/supported-editors/) when you need to compare every editor at once. Use this page when you want the exact terms, support details, and project/user targets for Codex.

Related aix concepts: [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## Editor-specific notes

* Codex prompts are converted into skills because aix no longer writes native prompt files for Codex.
* Codex upstream supports project-scoped MCP config, but aix still manages the global file today.

## Feature details

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

### Rules [Learn the concept](/concepts/rules/)

Section-managed markdown in project and directory-specific AGENTS.md files.

Codex calls this **AGENTS.md**

aix support Native

* Project

  Editor Supported aix Native

  Path `AGENTS.md at the project root and selected subdirectories`

* User

  Editor Supported aix Native

  Path `~/.codex/AGENTS.md`

- Activation modes collapse into plain markdown headings and directory placement.

### Prompts [Learn the concept](/concepts/prompts/)

Prompt-to-skill conversion during install.

Codex calls this **Skills**

aix support Adapter

* Project

  Editor Supported aix Adapter

  Path `.agents/skills/prompt-{name}/`

  **aix:** Prompts are installed as instruction-only Agent Skills.

* User

  Editor Supported aix Adapter

  Path `~/.codex/skills/prompt-{name}/`

  **aix:** User-scoped prompts are also converted to skills.

### MCP [Learn the concept](/concepts/mcp-servers/)

TOML MCP configuration currently managed as global-only by aix.

Codex calls this **MCP servers**

aix support Native

* Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix does not yet write Codex project MCP config.

* User

  Editor Supported aix Native

  Path `~/.codex/config.toml`

- Upstream Codex also supports `.codex/config.toml` in trusted projects.

### Skills [Learn the concept](/concepts/skills/)

Symlinked native skill directories backed by `.aix/skills/`.

Codex calls this **Skills**

aix support Native

* Project

  Editor Supported aix Native

  Path `.agents/skills/{name}/`

* User

  Editor Supported aix Native

  Path `~/.codex/skills/{name}/`

### Agents

Codex does not document custom subagent files that aix can write safely.

Codex calls this **Agents**

aix support No support

* Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Codex.

* User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Codex.

### Hooks [Learn the concept](/concepts/hooks/)

JSON hooks with Codex event names.

Codex calls this **Hooks**

aix support Native

* Project

  Editor Supported aix Native

  Path `.codex/hooks.json`

* User

  Editor Supported aix Native

  Path `~/.codex/hooks.json`

**Supported metadata:** `PermissionRequest` , `PostToolUse` , `PreToolUse` , `SessionStart` , `Stop` , `UserPromptSubmit`

* Codex command hooks use seconds-based `timeout` values.
* Codex currently runs command hooks only; aix reports prompt, agent, HTTP, and MCP hook handlers as unsupported fields.

### AGENTS.md

Codex natively layers AGENTS.md files through the directory tree.

Codex calls this **AGENTS.md**

aix support Native

* Project

  Editor Supported aix Native

  Path `AGENTS.md in the repository tree`

* User

  Editor Supported aix Native

  Path `~/.codex/AGENTS.md`

### .agents/skills

Codex natively discovers Agent Skills directories.

Codex calls this **.agents/skills**

aix support Native

* Project

  Editor Supported aix Native

  Path `.agents/skills/{name}/`

* User

  Editor Supported aix Native

  Path `~/.agents/skills/{name}/`

## Related guides

* [Codex to Cursor](/editors/migrations/how-to-migrate-from-codex-to-cursor/)
* [Cursor to Codex](/editors/migrations/how-to-migrate-from-cursor-to-codex/)
* [All migration guides that start from Codex](/editors/migrations/#codex)

---

# GitHub Copilot support details

> How aix maps rules, prompts, MCP, skills, hooks, and compatibility surfaces for GitHub Copilot.

Native project prompts, skill-backed user prompts, hooks, and repo-root MCP config.

Copilot keeps most features native, but its repo instruction surfaces differ from other editors.

Start on [the full support matrix](/editors/supported-editors/) when you need to compare every editor at once. Use this page when you want the exact terms, support details, and project/user targets for GitHub Copilot.

Related aix concepts: [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## Editor-specific notes

* aix writes project MCP config to `.mcp.json` and still imports `.github/mcp.json` as a fallback.
* Project Copilot prompt installs use explicit frontmatter so slash commands keep the configured prompt name.
* User-scope Copilot prompt installs are converted into native skills under `~/.config/github-copilot/skills/`.

## Feature details

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

### Rules [Learn the concept](/concepts/rules/)

Markdown instruction files in `.github/instructions/`.

GitHub Copilot calls this **Instructions**

aix support Native

* Project

  Editor Supported aix Native

  Path `.github/instructions/*.instructions.md`

* User

  Editor Supported aix No support

  Editor target `~/.config/github-copilot/instructions/*.instructions.md`

  **aix:** aix does not yet write user-scope Copilot instructions as separate files.

### Prompts [Learn the concept](/concepts/prompts/)

Markdown prompt files with YAML frontmatter.

GitHub Copilot calls this **Prompt files**

aix support Native

* Project

  Editor Supported aix Native

  Path `.github/prompts/*.prompt.md`

* User

  Editor Supported aix Adapter

  Path `~/.config/github-copilot/skills/{name}/`

  **aix:** aix converts user-scope prompts into instruction-only Copilot skills.

**Supported metadata:** `name` , `description` , `argument-hint`

### MCP [Learn the concept](/concepts/mcp-servers/)

JSON `mcpServers` configuration.

GitHub Copilot calls this **MCP servers**

aix support Native

* Project

  Editor Supported aix Native

  Path `.mcp.json`

* User

  Editor Supported aix Native

  Path `~/.config/github-copilot/mcp-config.json`

- Imports also fall back to `.github/mcp.json` when `.mcp.json` is absent.

### Skills [Learn the concept](/concepts/skills/)

Symlinked native skill directories backed by `.aix/skills/`.

GitHub Copilot calls this **Skills**

aix support Native

* Project

  Editor Supported aix Native

  Path `.github/skills/{name}/`

* User

  Editor Supported aix Native

  Path `~/.config/github-copilot/skills/{name}/`

- Copilot also discovers `.agents/skills/` as a compatibility surface.

### Agents

Markdown custom agent files with YAML frontmatter.

GitHub Copilot calls this **Agents**

aix support Native

* Project

  Editor Supported aix Native

  Path `.github/agents/*.md`

* User

  Editor Supported aix Native

  Path `~/.config/github-copilot/agents/*.md`

**Supported metadata:** `description` , `mode` , `model` , `tools` , `permissions` , `mcp-servers` , `editor.copilot`

### Hooks [Learn the concept](/concepts/hooks/)

JSON hooks with `version: 1`, matcher-based tool routing, and cross-platform `bash` / `powershell` fields.

GitHub Copilot calls this **Hooks**

aix support Native

* Project

  Editor Supported aix Native

  Path `.github/hooks/hooks.json`

* User

  Editor Supported aix Native

  Path `~/.config/github-copilot/hooks/hooks.json`

**Supported metadata:** `agentStop` , `errorOccurred` , `notification` , `permissionRequest` , `postToolUse` , `postToolUseFailure` , `preCompact` , `preToolUse` , `sessionEnd` , `sessionStart` , `subagentStart` , `subagentStop` , `userPromptSubmitted`

* Each command hook surfaces `bash`, `powershell`, `cwd`, `env`, and `timeoutSec` natively.
* `type: "prompt"` is supported on `sessionStart` only.

### AGENTS.md

Compatibility with repository AGENTS.md instructions.

GitHub Copilot calls this **AGENTS.md**

aix support Native

* Project

  Editor Supported aix Native

  Path `AGENTS.md in the repository tree`

* User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Copilot does not expose a dedicated home-scoped AGENTS.md target in aix.

### .agents/skills

Compatibility with the shared Agent Skills folder convention.

GitHub Copilot calls this **.agents/skills**

aix support Native

* Project

  Editor Supported aix Native

  Path `.agents/skills/{name}/`

* User

  Editor Supported aix Native

  Path `~/.agents/skills/{name}/`

## Related guides

* [GitHub Copilot to Cursor](/editors/migrations/how-to-migrate-from-copilot-to-cursor/)
* [Cursor to GitHub Copilot](/editors/migrations/how-to-migrate-from-cursor-to-copilot/)
* [All migration guides that start from GitHub Copilot](/editors/migrations/#copilot)

---

# Cursor support details

> How aix maps rules, prompts, MCP, skills, hooks, and compatibility surfaces for Cursor.

Native rules, commands, MCP, skills, and hooks with project-first config files.

Cursor keeps most aix features native, but rules stay project-scoped.

Start on [the full support matrix](/editors/supported-editors/) when you need to compare every editor at once. Use this page when you want the exact terms, support details, and project/user targets for Cursor.

Related aix concepts: [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## Editor-specific notes

* Cursor prompt installs use `.cursor/commands/`, not `.cursor/prompts/`.
* Cursor hooks map aix event names onto Cursor-specific camelCase hook names.

## Feature details

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

### Rules [Learn the concept](/concepts/rules/)

Markdown-with-frontmatter rule files.

Cursor calls this **Rules**

aix support Native

* Project

  Editor Supported aix Native

  Path `.cursor/rules/*.mdc`

* User

  Editor Supported aix No support

  Editor target `Settings UI`

  **Editor:** Cursor stores user rules in the Settings UI rather than a writable file. **aix:** aix does not currently write Cursor user rules.

**Supported metadata:** `alwaysApply` , `globs` , `description`

* Cursor also reads AGENTS.md as a compatibility surface.

### Prompts [Learn the concept](/concepts/prompts/)

Plain markdown command files.

Cursor calls this **Commands**

aix support Native

* Project

  Editor Supported aix Native

  Path `.cursor/commands/*.md`

* User

  Editor Supported aix Native

  Path `~/.cursor/commands/*.md`

### MCP [Learn the concept](/concepts/mcp-servers/)

JSON `mcpServers` configuration.

Cursor calls this **MCP servers**

aix support Native

* Project

  Editor Supported aix Native

  Path `.cursor/mcp.json`

* User

  Editor Supported aix Native

  Path `~/.cursor/mcp.json`

### Skills [Learn the concept](/concepts/skills/)

Symlinked native skill directories backed by `.aix/skills/`.

Cursor calls this **Skills**

aix support Native

* Project

  Editor Supported aix Native

  Path `.cursor/skills/{name}/`

* User

  Editor Supported aix Native

  Path `~/.cursor/skills/{name}/`

- Cursor also discovers `.agents/skills/` for compatibility.

### Agents

Markdown agent files with YAML frontmatter.

Cursor calls this **Agents**

aix support Native

* Project

  Editor Supported aix Native

  Path `.cursor/agents/*.md`

* User

  Editor Supported aix Native

  Path `~/.cursor/agents/*.md`

**Supported metadata:** `description` , `mode` , `model` , `tools` , `permissions` , `mcp` , `editor.cursor`

### Hooks [Learn the concept](/concepts/hooks/)

JSON hook configuration with event-name translation, wrapped with `version: 1`.

Cursor calls this **Hooks**

aix support Native

* Project

  Editor Supported aix Native

  Path `.cursor/hooks.json`

* User

  Editor Supported aix Native

  Path `~/.cursor/hooks.json`

**Supported metadata:** `sessionStart` , `sessionEnd` , `preToolUse` , `postToolUse` , `postToolUseFailure` , `subagentStart` , `subagentStop` , `beforeReadFile` , `beforeShellExecution` , `afterShellExecution` , `beforeMCPExecution` , `afterMCPExecution` , `afterFileEdit` , `beforeSubmitPrompt` , `preCompact` , `afterAgentResponse` , `afterAgentThought` , `stop` , `beforeTabFileRead` , `afterTabFileEdit`

* Cursor also supports `type: "prompt"` LLM-evaluated hooks; aix passes them through.

### AGENTS.md

Compatibility with root-level AGENTS.md instructions.

Cursor calls this **AGENTS.md**

aix support Native

* Project

  Editor Supported aix Native

  Path `AGENTS.md`

* User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Cursor does not expose a separate home-scoped AGENTS.md path in aix.

### .agents/skills

Compatibility with the shared Agent Skills folder convention.

Cursor calls this **.agents/skills**

aix support Native

* Project

  Editor Supported aix Native

  Path `.agents/skills/{name}/`

* User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Cursor documents project-level compatibility more clearly than home scope.

## Related guides

* [Cursor to GitHub Copilot](/editors/migrations/how-to-migrate-from-cursor-to-copilot/)
* [GitHub Copilot to Cursor](/editors/migrations/how-to-migrate-from-copilot-to-cursor/)
* [All migration guides that start from Cursor](/editors/migrations/#cursor)

---

# Gemini support details

> How aix maps rules, prompts, MCP, skills, hooks, and compatibility surfaces for Gemini.

Native GEMINI.md rules, TOML command prompts, MCP, skills, and hooks.

Gemini is a strong target for native prompts, MCP, and the new hooks system.

Start on [the full support matrix](/editors/supported-editors/) when you need to compare every editor at once. Use this page when you want the exact terms, support details, and project/user targets for Gemini.

Related aix concepts: [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## Editor-specific notes

* Gemini prompts are TOML files, not markdown command files.
* Like Codex, Gemini collapses rule activation metadata into managed markdown content.
* Gemini hooks share `.gemini/settings.json` with MCP; aix merges both blocks safely.

## Feature details

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

### Rules [Learn the concept](/concepts/rules/)

Section-managed markdown in `GEMINI.md`.

Gemini calls this **GEMINI.md**

aix support Native

* Project

  Editor Supported aix Native

  Path `GEMINI.md`

* User

  Editor Supported aix Native

  Path `~/.gemini/GEMINI.md`

- Activation modes are flattened into the managed markdown section.

### Prompts [Learn the concept](/concepts/prompts/)

TOML command files with `description` and `prompt` fields.

Gemini calls this **Commands**

aix support Native

* Project

  Editor Supported aix Native

  Path `.gemini/commands/*.toml`

* User

  Editor Supported aix Native

  Path `~/.gemini/commands/*.toml`

### MCP [Learn the concept](/concepts/mcp-servers/)

JSON settings file with editor-native MCP config.

Gemini calls this **MCP servers**

aix support Native

* Project

  Editor Supported aix Native

  Path `.gemini/settings.json`

* User

  Editor Supported aix Native

  Path `~/.gemini/settings.json`

### Skills [Learn the concept](/concepts/skills/)

Symlinked native skill directories backed by `.aix/skills/`.

Gemini calls this **Skills**

aix support Native

* Project

  Editor Supported aix Native

  Path `.gemini/skills/{name}/`

* User

  Editor Supported aix Native

  Path `~/.gemini/skills/{name}/`

- Gemini also supports `.agents/skills/` as an alias and gives it precedence.

### Agents

Markdown subagent files with YAML frontmatter.

Gemini calls this **Subagents**

aix support Native

* Project

  Editor Supported aix Native

  Path `.gemini/agents/*.md`

* User

  Editor Supported aix Native

  Path `~/.gemini/agents/*.md`

**Supported metadata:** `description` , `mode` , `model` , `tools` , `temperature` , `maxTurns` , `editor.gemini`

### Hooks [Learn the concept](/concepts/hooks/)

JSON hooks under `hooks` in `settings.json` with PascalCase event names.

Gemini calls this **Hooks**

aix support Native

* Project

  Editor Supported aix Native

  Path `.gemini/settings.json`

* User

  Editor Supported aix Native

  Path `~/.gemini/settings.json`

**Supported metadata:** `AfterAgent` , `AfterModel` , `AfterTool` , `BeforeAgent` , `BeforeModel` , `BeforeTool` , `BeforeToolSelection` , `Notification` , `PreCompress` , `SessionEnd` , `SessionStart`

* `timeout` is in milliseconds (Gemini default 60000); aix multiplies seconds-based input by 1000.
* Hook groups also accept `sequential: true` to run actions one at a time instead of in parallel.

### AGENTS.md

Compatibility with AGENTS.md through configurable context filename support.

Gemini calls this **AGENTS.md**

aix support Native

* Project

  Editor Supported aix Native

  Path ``AGENTS.md when `context.fileName` is configured``

* User

  Editor Supported aix Native

  Path ``Home-scoped AGENTS.md when `context.fileName` is configured``

### .agents/skills

Compatibility with the shared Agent Skills folder convention.

Gemini calls this **.agents/skills**

aix support Native

* Project

  Editor Supported aix Native

  Path `.agents/skills/{name}/`

* User

  Editor Supported aix Native

  Path `~/.agents/skills/{name}/`

## Related guides

* [Gemini to Cursor](/editors/migrations/how-to-migrate-from-gemini-to-cursor/)
* [Cursor to Gemini](/editors/migrations/how-to-migrate-from-cursor-to-gemini/)
* [All migration guides that start from Gemini](/editors/migrations/#gemini)

---

# Migration Guides

> Programmatic editor-to-editor migration guides for every supported aix editor pair.

Start with the editor you use today. Each guide shows what aix can carry over, what the destination editor calls each feature, and where project or user config ends up.

The guides are especially useful if you found aix through a search like "How to migrate from X to Y" and want a quick comparison before you run `aix sync`.

## From Cursor

To GitHub Copilot

[How to migrate from Cursor to GitHub Copilot](/editors/migrations/how-to-migrate-from-cursor-to-copilot/)

To Claude Code

[How to migrate from Cursor to Claude Code](/editors/migrations/how-to-migrate-from-cursor-to-claude-code/)

To Windsurf

[How to migrate from Cursor to Windsurf](/editors/migrations/how-to-migrate-from-cursor-to-windsurf/)

To Zed

[How to migrate from Cursor to Zed](/editors/migrations/how-to-migrate-from-cursor-to-zed/)

To Codex

[How to migrate from Cursor to Codex](/editors/migrations/how-to-migrate-from-cursor-to-codex/)

To Gemini

[How to migrate from Cursor to Gemini](/editors/migrations/how-to-migrate-from-cursor-to-gemini/)

To OpenCode

[How to migrate from Cursor to OpenCode](/editors/migrations/how-to-migrate-from-cursor-to-opencode/)

## From GitHub Copilot

To Cursor

[How to migrate from GitHub Copilot to Cursor](/editors/migrations/how-to-migrate-from-copilot-to-cursor/)

To Claude Code

[How to migrate from GitHub Copilot to Claude Code](/editors/migrations/how-to-migrate-from-copilot-to-claude-code/)

To Windsurf

[How to migrate from GitHub Copilot to Windsurf](/editors/migrations/how-to-migrate-from-copilot-to-windsurf/)

To Zed

[How to migrate from GitHub Copilot to Zed](/editors/migrations/how-to-migrate-from-copilot-to-zed/)

To Codex

[How to migrate from GitHub Copilot to Codex](/editors/migrations/how-to-migrate-from-copilot-to-codex/)

To Gemini

[How to migrate from GitHub Copilot to Gemini](/editors/migrations/how-to-migrate-from-copilot-to-gemini/)

To OpenCode

[How to migrate from GitHub Copilot to OpenCode](/editors/migrations/how-to-migrate-from-copilot-to-opencode/)

## From Claude Code

To Cursor

[How to migrate from Claude Code to Cursor](/editors/migrations/how-to-migrate-from-claude-code-to-cursor/)

To GitHub Copilot

[How to migrate from Claude Code to GitHub Copilot](/editors/migrations/how-to-migrate-from-claude-code-to-copilot/)

To Windsurf

[How to migrate from Claude Code to Windsurf](/editors/migrations/how-to-migrate-from-claude-code-to-windsurf/)

To Zed

[How to migrate from Claude Code to Zed](/editors/migrations/how-to-migrate-from-claude-code-to-zed/)

To Codex

[How to migrate from Claude Code to Codex](/editors/migrations/how-to-migrate-from-claude-code-to-codex/)

To Gemini

[How to migrate from Claude Code to Gemini](/editors/migrations/how-to-migrate-from-claude-code-to-gemini/)

To OpenCode

[How to migrate from Claude Code to OpenCode](/editors/migrations/how-to-migrate-from-claude-code-to-opencode/)

## From Windsurf

To Cursor

[How to migrate from Windsurf to Cursor](/editors/migrations/how-to-migrate-from-windsurf-to-cursor/)

To GitHub Copilot

[How to migrate from Windsurf to GitHub Copilot](/editors/migrations/how-to-migrate-from-windsurf-to-copilot/)

To Claude Code

[How to migrate from Windsurf to Claude Code](/editors/migrations/how-to-migrate-from-windsurf-to-claude-code/)

To Zed

[How to migrate from Windsurf to Zed](/editors/migrations/how-to-migrate-from-windsurf-to-zed/)

To Codex

[How to migrate from Windsurf to Codex](/editors/migrations/how-to-migrate-from-windsurf-to-codex/)

To Gemini

[How to migrate from Windsurf to Gemini](/editors/migrations/how-to-migrate-from-windsurf-to-gemini/)

To OpenCode

[How to migrate from Windsurf to OpenCode](/editors/migrations/how-to-migrate-from-windsurf-to-opencode/)

## From Zed

To Cursor

[How to migrate from Zed to Cursor](/editors/migrations/how-to-migrate-from-zed-to-cursor/)

To GitHub Copilot

[How to migrate from Zed to GitHub Copilot](/editors/migrations/how-to-migrate-from-zed-to-copilot/)

To Claude Code

[How to migrate from Zed to Claude Code](/editors/migrations/how-to-migrate-from-zed-to-claude-code/)

To Windsurf

[How to migrate from Zed to Windsurf](/editors/migrations/how-to-migrate-from-zed-to-windsurf/)

To Codex

[How to migrate from Zed to Codex](/editors/migrations/how-to-migrate-from-zed-to-codex/)

To Gemini

[How to migrate from Zed to Gemini](/editors/migrations/how-to-migrate-from-zed-to-gemini/)

To OpenCode

[How to migrate from Zed to OpenCode](/editors/migrations/how-to-migrate-from-zed-to-opencode/)

## From Codex

To Cursor

[How to migrate from Codex to Cursor](/editors/migrations/how-to-migrate-from-codex-to-cursor/)

To GitHub Copilot

[How to migrate from Codex to GitHub Copilot](/editors/migrations/how-to-migrate-from-codex-to-copilot/)

To Claude Code

[How to migrate from Codex to Claude Code](/editors/migrations/how-to-migrate-from-codex-to-claude-code/)

To Windsurf

[How to migrate from Codex to Windsurf](/editors/migrations/how-to-migrate-from-codex-to-windsurf/)

To Zed

[How to migrate from Codex to Zed](/editors/migrations/how-to-migrate-from-codex-to-zed/)

To Gemini

[How to migrate from Codex to Gemini](/editors/migrations/how-to-migrate-from-codex-to-gemini/)

To OpenCode

[How to migrate from Codex to OpenCode](/editors/migrations/how-to-migrate-from-codex-to-opencode/)

## From Gemini

To Cursor

[How to migrate from Gemini to Cursor](/editors/migrations/how-to-migrate-from-gemini-to-cursor/)

To GitHub Copilot

[How to migrate from Gemini to GitHub Copilot](/editors/migrations/how-to-migrate-from-gemini-to-copilot/)

To Claude Code

[How to migrate from Gemini to Claude Code](/editors/migrations/how-to-migrate-from-gemini-to-claude-code/)

To Windsurf

[How to migrate from Gemini to Windsurf](/editors/migrations/how-to-migrate-from-gemini-to-windsurf/)

To Zed

[How to migrate from Gemini to Zed](/editors/migrations/how-to-migrate-from-gemini-to-zed/)

To Codex

[How to migrate from Gemini to Codex](/editors/migrations/how-to-migrate-from-gemini-to-codex/)

To OpenCode

[How to migrate from Gemini to OpenCode](/editors/migrations/how-to-migrate-from-gemini-to-opencode/)

## From OpenCode

To Cursor

[How to migrate from OpenCode to Cursor](/editors/migrations/how-to-migrate-from-opencode-to-cursor/)

To GitHub Copilot

[How to migrate from OpenCode to GitHub Copilot](/editors/migrations/how-to-migrate-from-opencode-to-copilot/)

To Claude Code

[How to migrate from OpenCode to Claude Code](/editors/migrations/how-to-migrate-from-opencode-to-claude-code/)

To Windsurf

[How to migrate from OpenCode to Windsurf](/editors/migrations/how-to-migrate-from-opencode-to-windsurf/)

To Zed

[How to migrate from OpenCode to Zed](/editors/migrations/how-to-migrate-from-opencode-to-zed/)

To Codex

[How to migrate from OpenCode to Codex](/editors/migrations/how-to-migrate-from-opencode-to-codex/)

To Gemini

[How to migrate from OpenCode to Gemini](/editors/migrations/how-to-migrate-from-opencode-to-gemini/)

---

# How to migrate from Claude Code to Codex

> Compare Claude Code to Codex, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Claude Code to Codex, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync claude-code --to codex` copies the supported config from Claude Code into Codex. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Claude Code                                                                                                                                                   | Codex                                                                                                                                                                                                                                                                                                                                                                             |
| ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **Rules**- Project

  Editor Supported aix Native

  Path `.claude/rules/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/CLAUDE.md`           | **AGENTS.md**- Project

  Editor Supported aix Native

  Path `AGENTS.md at the project root and selected subdirectories`

- User

  Editor Supported aix Native

  Path `~/.codex/AGENTS.md`                                                                                                                                                                                     |
| [Prompts](/concepts/prompts/) | **Commands**- Project

  Editor Supported aix Native

  Path `.claude/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/commands/*.md` | **Skills**- Project

  Editor Supported aix Adapter

  Path `.agents/skills/prompt-{name}/`

  **aix:** Prompts are installed as instruction-only Agent Skills.

- User

  Editor Supported aix Adapter

  Path `~/.codex/skills/prompt-{name}/`

  **aix:** User-scoped prompts are also converted to skills.                                                                    |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor Supported aix Native

  Path `.mcp.json`

- User

  Editor Supported aix Native

  Path `~/.claude.json`                   | **MCP servers**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix does not yet write Codex project MCP config.

- User

  Editor Supported aix Native

  Path `~/.codex/config.toml`                                                                                                                |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.claude/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.claude/skills/{name}/` | **Skills**- Project

  Editor Supported aix Native

  Path `.agents/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.codex/skills/{name}/`                                                                                                                                                                                                                      |
| Agents                        | **Subagents**- Project

  Editor Supported aix Native

  Path `.claude/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/agents/*.md`    | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Codex.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Codex. |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.claude/settings.json`

- User

  Editor Supported aix Native

  Path `~/.claude/settings.json`    | **Hooks**- Project

  Editor Supported aix Native

  Path `.codex/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.codex/hooks.json`                                                                                                                                                                                                                                |

## Recommended follow-up links

* [Claude Code support details](/editors/claude-code/)
* [Codex support details](/editors/codex/)
* [All guides that start from Claude Code](/editors/migrations/#claude-code)
* [Codex to Claude Code](/editors/migrations/how-to-migrate-from-codex-to-claude-code/)

---

# How to migrate from Claude Code to GitHub Copilot

> Compare Claude Code to GitHub Copilot, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Claude Code to GitHub Copilot, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync claude-code --to copilot` copies the supported config from Claude Code into GitHub Copilot. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Claude Code                                                                                                                                                   | GitHub Copilot                                                                                                                                                                                                                                                                                                        |
| ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **Rules**- Project

  Editor Supported aix Native

  Path `.claude/rules/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/CLAUDE.md`           | **Instructions**- Project

  Editor Supported aix Native

  Path `.github/instructions/*.instructions.md`

- User

  Editor Supported aix No support

  Editor target `~/.config/github-copilot/instructions/*.instructions.md`

  **aix:** aix does not yet write user-scope Copilot instructions as separate files. |
| [Prompts](/concepts/prompts/) | **Commands**- Project

  Editor Supported aix Native

  Path `.claude/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/commands/*.md` | **Prompt files**- Project

  Editor Supported aix Native

  Path `.github/prompts/*.prompt.md`

- User

  Editor Supported aix Adapter

  Path `~/.config/github-copilot/skills/{name}/`

  **aix:** aix converts user-scope prompts into instruction-only Copilot skills.                                            |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor Supported aix Native

  Path `.mcp.json`

- User

  Editor Supported aix Native

  Path `~/.claude.json`                   | **MCP servers**- Project

  Editor Supported aix Native

  Path `.mcp.json`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/mcp-config.json`                                                                                                                                                 |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.claude/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.claude/skills/{name}/` | **Skills**- Project

  Editor Supported aix Native

  Path `.github/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/skills/{name}/`                                                                                                                                          |
| Agents                        | **Subagents**- Project

  Editor Supported aix Native

  Path `.claude/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/agents/*.md`    | **Agents**- Project

  Editor Supported aix Native

  Path `.github/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/agents/*.md`                                                                                                                                                |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.claude/settings.json`

- User

  Editor Supported aix Native

  Path `~/.claude/settings.json`    | **Hooks**- Project

  Editor Supported aix Native

  Path `.github/hooks/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/hooks/hooks.json`                                                                                                                                       |

## Recommended follow-up links

* [Claude Code support details](/editors/claude-code/)
* [GitHub Copilot support details](/editors/copilot/)
* [All guides that start from Claude Code](/editors/migrations/#claude-code)
* [GitHub Copilot to Claude Code](/editors/migrations/how-to-migrate-from-copilot-to-claude-code/)

---

# How to migrate from Claude Code to Cursor

> Compare Claude Code to Cursor, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Claude Code to Cursor, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync claude-code --to cursor` copies the supported config from Claude Code into Cursor. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Claude Code                                                                                                                                                   | Cursor                                                                                                                                                                                                                                                                                                     |
| ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **Rules**- Project

  Editor Supported aix Native

  Path `.claude/rules/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/CLAUDE.md`           | **Rules**- Project

  Editor Supported aix Native

  Path `.cursor/rules/*.mdc`

- User

  Editor Supported aix No support

  Editor target `Settings UI`

  **Editor:** Cursor stores user rules in the Settings UI rather than a writable file. **aix:** aix does not currently write Cursor user rules. |
| [Prompts](/concepts/prompts/) | **Commands**- Project

  Editor Supported aix Native

  Path `.claude/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/commands/*.md` | **Commands**- Project

  Editor Supported aix Native

  Path `.cursor/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.cursor/commands/*.md`                                                                                                                                              |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor Supported aix Native

  Path `.mcp.json`

- User

  Editor Supported aix Native

  Path `~/.claude.json`                   | **MCP servers**- Project

  Editor Supported aix Native

  Path `.cursor/mcp.json`

- User

  Editor Supported aix Native

  Path `~/.cursor/mcp.json`                                                                                                                                                     |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.claude/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.claude/skills/{name}/` | **Skills**- Project

  Editor Supported aix Native

  Path `.cursor/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.cursor/skills/{name}/`                                                                                                                                              |
| Agents                        | **Subagents**- Project

  Editor Supported aix Native

  Path `.claude/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/agents/*.md`    | **Agents**- Project

  Editor Supported aix Native

  Path `.cursor/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.cursor/agents/*.md`                                                                                                                                                    |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.claude/settings.json`

- User

  Editor Supported aix Native

  Path `~/.claude/settings.json`    | **Hooks**- Project

  Editor Supported aix Native

  Path `.cursor/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.cursor/hooks.json`                                                                                                                                                       |

## Recommended follow-up links

* [Claude Code support details](/editors/claude-code/)
* [Cursor support details](/editors/cursor/)
* [All guides that start from Claude Code](/editors/migrations/#claude-code)
* [Cursor to Claude Code](/editors/migrations/how-to-migrate-from-cursor-to-claude-code/)

---

# How to migrate from Claude Code to Gemini

> Compare Claude Code to Gemini, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Claude Code to Gemini, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync claude-code --to gemini` copies the supported config from Claude Code into Gemini. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Claude Code                                                                                                                                                   | Gemini                                                                                                                                                            |
| ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **Rules**- Project

  Editor Supported aix Native

  Path `.claude/rules/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/CLAUDE.md`           | **GEMINI.md**- Project

  Editor Supported aix Native

  Path `GEMINI.md`

- User

  Editor Supported aix Native

  Path `~/.gemini/GEMINI.md`                    |
| [Prompts](/concepts/prompts/) | **Commands**- Project

  Editor Supported aix Native

  Path `.claude/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/commands/*.md` | **Commands**- Project

  Editor Supported aix Native

  Path `.gemini/commands/*.toml`

- User

  Editor Supported aix Native

  Path `~/.gemini/commands/*.toml` |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor Supported aix Native

  Path `.mcp.json`

- User

  Editor Supported aix Native

  Path `~/.claude.json`                   | **MCP servers**- Project

  Editor Supported aix Native

  Path `.gemini/settings.json`

- User

  Editor Supported aix Native

  Path `~/.gemini/settings.json`  |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.claude/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.claude/skills/{name}/` | **Skills**- Project

  Editor Supported aix Native

  Path `.gemini/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.gemini/skills/{name}/`     |
| Agents                        | **Subagents**- Project

  Editor Supported aix Native

  Path `.claude/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/agents/*.md`    | **Subagents**- Project

  Editor Supported aix Native

  Path `.gemini/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.gemini/agents/*.md`        |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.claude/settings.json`

- User

  Editor Supported aix Native

  Path `~/.claude/settings.json`    | **Hooks**- Project

  Editor Supported aix Native

  Path `.gemini/settings.json`

- User

  Editor Supported aix Native

  Path `~/.gemini/settings.json`        |

## Recommended follow-up links

* [Claude Code support details](/editors/claude-code/)
* [Gemini support details](/editors/gemini/)
* [All guides that start from Claude Code](/editors/migrations/#claude-code)
* [Gemini to Claude Code](/editors/migrations/how-to-migrate-from-gemini-to-claude-code/)

---

# How to migrate from Claude Code to OpenCode

> Compare Claude Code to OpenCode, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Claude Code to OpenCode, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync claude-code --to opencode` copies the supported config from Claude Code into OpenCode. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Claude Code                                                                                                                                                   | OpenCode                                                                                                                                                                                                                                                                                                                                                             |
| ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **Rules**- Project

  Editor Supported aix Native

  Path `.claude/rules/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/CLAUDE.md`           | **AGENTS.md**- Project

  Editor Supported aix Native

  Path `AGENTS.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/AGENTS.md`                                                                                                                                                                                                              |
| [Prompts](/concepts/prompts/) | **Commands**- Project

  Editor Supported aix Native

  Path `.claude/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/commands/*.md` | **Commands**- Project

  Editor Supported aix Native

  Path `.opencode/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/commands/*.md`                                                                                                                                                                                             |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor Supported aix Native

  Path `.mcp.json`

- User

  Editor Supported aix Native

  Path `~/.claude.json`                   | **MCP servers**- Project

  Editor Supported aix Native

  Path `opencode.json`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/opencode.json`                                                                                                                                                                                                    |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.claude/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.claude/skills/{name}/` | **Skills**- Project

  Editor Supported aix Native

  Path `.opencode/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/skills/{name}/`                                                                                                                                                                                             |
| Agents                        | **Subagents**- Project

  Editor Supported aix Native

  Path `.claude/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/agents/*.md`    | **Agents**- Project

  Editor Supported aix Native

  Path `.opencode/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/agents/*.md`                                                                                                                                                                                                   |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.claude/settings.json`

- User

  Editor Supported aix Native

  Path `~/.claude/settings.json`    | **Hooks**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** OpenCode does not support lifecycle hooks in aix.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** OpenCode does not support lifecycle hooks in aix. |

## Recommended follow-up links

* [Claude Code support details](/editors/claude-code/)
* [OpenCode support details](/editors/opencode/)
* [All guides that start from Claude Code](/editors/migrations/#claude-code)
* [OpenCode to Claude Code](/editors/migrations/how-to-migrate-from-opencode-to-claude-code/)

---

# How to migrate from Claude Code to Windsurf

> Compare Claude Code to Windsurf, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Claude Code to Windsurf, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync claude-code --to windsurf` copies the supported config from Claude Code into Windsurf. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Claude Code                                                                                                                                                   | Windsurf                                                                                                                                                                                                                                                                                                                                                                                |
| ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **Rules**- Project

  Editor Supported aix Native

  Path `.claude/rules/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/CLAUDE.md`           | **Rules**- Project

  Editor Supported aix Native

  Path `.windsurf/rules/*.md`

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/memories/global_rules.md`                                                                                                                                                                                                          |
| [Prompts](/concepts/prompts/) | **Commands**- Project

  Editor Supported aix Native

  Path `.claude/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/commands/*.md` | **Workflows**- Project

  Editor Supported aix Native

  Path `.windsurf/workflows/*.md`

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/global_workflows/*.md`                                                                                                                                                                                                     |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor Supported aix Native

  Path `.mcp.json`

- User

  Editor Supported aix Native

  Path `~/.claude.json`                   | **MCP servers**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Windsurf does not have a project-scoped MCP config file in aix.

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/mcp_config.json`                                                                                        |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.claude/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.claude/skills/{name}/` | **Skills**- Project

  Editor Supported aix Native

  Path `.windsurf/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.windsurf/skills/{name}/`                                                                                                                                                                                                                       |
| Agents                        | **Subagents**- Project

  Editor Supported aix Native

  Path `.claude/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/agents/*.md`    | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Windsurf.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Windsurf. |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.claude/settings.json`

- User

  Editor Supported aix Native

  Path `~/.claude/settings.json`    | **Hooks**- Project

  Editor Supported aix Native

  Path `.windsurf/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.windsurf/hooks.json`                                                                                                                                                                                                                                |

## Recommended follow-up links

* [Claude Code support details](/editors/claude-code/)
* [Windsurf support details](/editors/windsurf/)
* [All guides that start from Claude Code](/editors/migrations/#claude-code)
* [Windsurf to Claude Code](/editors/migrations/how-to-migrate-from-windsurf-to-claude-code/)

---

# How to migrate from Claude Code to Zed

> Compare Claude Code to Zed, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Claude Code to Zed, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync claude-code --to zed` copies the supported config from Claude Code into Zed. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Claude Code                                                                                                                                                   | Zed                                                                                                                                                                                                                                                                                                                                                                           |
| ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **Rules**- Project

  Editor Supported aix Native

  Path `.claude/rules/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/CLAUDE.md`           | **Rules**- Project

  Editor Supported aix Native

  Path `.rules`

- User

  Editor Supported aix Native

  Path `~/.config/zed/AGENTS.md`                                                                                                                                                                                                                                   |
| [Prompts](/concepts/prompts/) | **Commands**- Project

  Editor Supported aix Native

  Path `.claude/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/commands/*.md` | **Agent Skills (converted)**- Project

  Editor Supported aix Adapter

  Path `.agents/skills/`

  **aix:** aix converts prompts to Agent Skills in `.agents/skills/<name>/`.

- User

  Editor Supported aix Adapter

  Path `~/.agents/skills/`

  **aix:** aix converts prompts to Agent Skills in `~/.agents/skills/<name>/`.                                             |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor Supported aix Native

  Path `.mcp.json`

- User

  Editor Supported aix Native

  Path `~/.claude.json`                   | **Context servers**- Project

  Editor Supported aix Native

  Path `.zed/settings.json`

- User

  Editor Supported aix Native

  Path `~/.config/zed/settings.json`                                                                                                                                                                                                         |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.claude/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.claude/skills/{name}/` | **Agent Skills**- Project

  Editor Supported aix Native

  Path `.agents/skills/`

- User

  Editor Supported aix Native

  Path `~/.agents/skills/`                                                                                                                                                                                                                         |
| Agents                        | **Subagents**- Project

  Editor Supported aix Native

  Path `.claude/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/agents/*.md`    | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Zed.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Zed. |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.claude/settings.json`

- User

  Editor Supported aix Native

  Path `~/.claude/settings.json`    | **Hooks**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Zed does not support lifecycle hooks in aix.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Zed does not support lifecycle hooks in aix.                    |

## Recommended follow-up links

* [Claude Code support details](/editors/claude-code/)
* [Zed support details](/editors/zed/)
* [All guides that start from Claude Code](/editors/migrations/#claude-code)
* [Zed to Claude Code](/editors/migrations/how-to-migrate-from-zed-to-claude-code/)

---

# How to migrate from Codex to Claude Code

> Compare Codex to Claude Code, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Codex to Claude Code, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync codex --to claude-code` copies the supported config from Codex into Claude Code. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Codex                                                                                                                                                                                                                                                                                                                                                                             | Claude Code                                                                                                                                                   |
| ----------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **AGENTS.md**- Project

  Editor Supported aix Native

  Path `AGENTS.md at the project root and selected subdirectories`

- User

  Editor Supported aix Native

  Path `~/.codex/AGENTS.md`                                                                                                                                                                                     | **Rules**- Project

  Editor Supported aix Native

  Path `.claude/rules/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/CLAUDE.md`           |
| [Prompts](/concepts/prompts/) | **Skills**- Project

  Editor Supported aix Adapter

  Path `.agents/skills/prompt-{name}/`

  **aix:** Prompts are installed as instruction-only Agent Skills.

- User

  Editor Supported aix Adapter

  Path `~/.codex/skills/prompt-{name}/`

  **aix:** User-scoped prompts are also converted to skills.                                                                    | **Commands**- Project

  Editor Supported aix Native

  Path `.claude/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/commands/*.md` |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix does not yet write Codex project MCP config.

- User

  Editor Supported aix Native

  Path `~/.codex/config.toml`                                                                                                                | **MCP servers**- Project

  Editor Supported aix Native

  Path `.mcp.json`

- User

  Editor Supported aix Native

  Path `~/.claude.json`                   |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.agents/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.codex/skills/{name}/`                                                                                                                                                                                                                      | **Skills**- Project

  Editor Supported aix Native

  Path `.claude/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.claude/skills/{name}/` |
| Agents                        | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Codex.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Codex. | **Subagents**- Project

  Editor Supported aix Native

  Path `.claude/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/agents/*.md`    |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.codex/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.codex/hooks.json`                                                                                                                                                                                                                                | **Hooks**- Project

  Editor Supported aix Native

  Path `.claude/settings.json`

- User

  Editor Supported aix Native

  Path `~/.claude/settings.json`    |

## Recommended follow-up links

* [Codex support details](/editors/codex/)
* [Claude Code support details](/editors/claude-code/)
* [All guides that start from Codex](/editors/migrations/#codex)
* [Claude Code to Codex](/editors/migrations/how-to-migrate-from-claude-code-to-codex/)

---

# How to migrate from Codex to GitHub Copilot

> Compare Codex to GitHub Copilot, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Codex to GitHub Copilot, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync codex --to copilot` copies the supported config from Codex into GitHub Copilot. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Codex                                                                                                                                                                                                                                                                                                                                                                             | GitHub Copilot                                                                                                                                                                                                                                                                                                        |
| ----------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **AGENTS.md**- Project

  Editor Supported aix Native

  Path `AGENTS.md at the project root and selected subdirectories`

- User

  Editor Supported aix Native

  Path `~/.codex/AGENTS.md`                                                                                                                                                                                     | **Instructions**- Project

  Editor Supported aix Native

  Path `.github/instructions/*.instructions.md`

- User

  Editor Supported aix No support

  Editor target `~/.config/github-copilot/instructions/*.instructions.md`

  **aix:** aix does not yet write user-scope Copilot instructions as separate files. |
| [Prompts](/concepts/prompts/) | **Skills**- Project

  Editor Supported aix Adapter

  Path `.agents/skills/prompt-{name}/`

  **aix:** Prompts are installed as instruction-only Agent Skills.

- User

  Editor Supported aix Adapter

  Path `~/.codex/skills/prompt-{name}/`

  **aix:** User-scoped prompts are also converted to skills.                                                                    | **Prompt files**- Project

  Editor Supported aix Native

  Path `.github/prompts/*.prompt.md`

- User

  Editor Supported aix Adapter

  Path `~/.config/github-copilot/skills/{name}/`

  **aix:** aix converts user-scope prompts into instruction-only Copilot skills.                                            |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix does not yet write Codex project MCP config.

- User

  Editor Supported aix Native

  Path `~/.codex/config.toml`                                                                                                                | **MCP servers**- Project

  Editor Supported aix Native

  Path `.mcp.json`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/mcp-config.json`                                                                                                                                                 |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.agents/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.codex/skills/{name}/`                                                                                                                                                                                                                      | **Skills**- Project

  Editor Supported aix Native

  Path `.github/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/skills/{name}/`                                                                                                                                          |
| Agents                        | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Codex.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Codex. | **Agents**- Project

  Editor Supported aix Native

  Path `.github/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/agents/*.md`                                                                                                                                                |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.codex/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.codex/hooks.json`                                                                                                                                                                                                                                | **Hooks**- Project

  Editor Supported aix Native

  Path `.github/hooks/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/hooks/hooks.json`                                                                                                                                       |

## Recommended follow-up links

* [Codex support details](/editors/codex/)
* [GitHub Copilot support details](/editors/copilot/)
* [All guides that start from Codex](/editors/migrations/#codex)
* [GitHub Copilot to Codex](/editors/migrations/how-to-migrate-from-copilot-to-codex/)

---

# How to migrate from Codex to Cursor

> Compare Codex to Cursor, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Codex to Cursor, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync codex --to cursor` copies the supported config from Codex into Cursor. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Codex                                                                                                                                                                                                                                                                                                                                                                             | Cursor                                                                                                                                                                                                                                                                                                     |
| ----------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **AGENTS.md**- Project

  Editor Supported aix Native

  Path `AGENTS.md at the project root and selected subdirectories`

- User

  Editor Supported aix Native

  Path `~/.codex/AGENTS.md`                                                                                                                                                                                     | **Rules**- Project

  Editor Supported aix Native

  Path `.cursor/rules/*.mdc`

- User

  Editor Supported aix No support

  Editor target `Settings UI`

  **Editor:** Cursor stores user rules in the Settings UI rather than a writable file. **aix:** aix does not currently write Cursor user rules. |
| [Prompts](/concepts/prompts/) | **Skills**- Project

  Editor Supported aix Adapter

  Path `.agents/skills/prompt-{name}/`

  **aix:** Prompts are installed as instruction-only Agent Skills.

- User

  Editor Supported aix Adapter

  Path `~/.codex/skills/prompt-{name}/`

  **aix:** User-scoped prompts are also converted to skills.                                                                    | **Commands**- Project

  Editor Supported aix Native

  Path `.cursor/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.cursor/commands/*.md`                                                                                                                                              |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix does not yet write Codex project MCP config.

- User

  Editor Supported aix Native

  Path `~/.codex/config.toml`                                                                                                                | **MCP servers**- Project

  Editor Supported aix Native

  Path `.cursor/mcp.json`

- User

  Editor Supported aix Native

  Path `~/.cursor/mcp.json`                                                                                                                                                     |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.agents/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.codex/skills/{name}/`                                                                                                                                                                                                                      | **Skills**- Project

  Editor Supported aix Native

  Path `.cursor/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.cursor/skills/{name}/`                                                                                                                                              |
| Agents                        | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Codex.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Codex. | **Agents**- Project

  Editor Supported aix Native

  Path `.cursor/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.cursor/agents/*.md`                                                                                                                                                    |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.codex/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.codex/hooks.json`                                                                                                                                                                                                                                | **Hooks**- Project

  Editor Supported aix Native

  Path `.cursor/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.cursor/hooks.json`                                                                                                                                                       |

## Recommended follow-up links

* [Codex support details](/editors/codex/)
* [Cursor support details](/editors/cursor/)
* [All guides that start from Codex](/editors/migrations/#codex)
* [Cursor to Codex](/editors/migrations/how-to-migrate-from-cursor-to-codex/)

---

# How to migrate from Codex to Gemini

> Compare Codex to Gemini, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Codex to Gemini, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync codex --to gemini` copies the supported config from Codex into Gemini. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Codex                                                                                                                                                                                                                                                                                                                                                                             | Gemini                                                                                                                                                            |
| ----------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **AGENTS.md**- Project

  Editor Supported aix Native

  Path `AGENTS.md at the project root and selected subdirectories`

- User

  Editor Supported aix Native

  Path `~/.codex/AGENTS.md`                                                                                                                                                                                     | **GEMINI.md**- Project

  Editor Supported aix Native

  Path `GEMINI.md`

- User

  Editor Supported aix Native

  Path `~/.gemini/GEMINI.md`                    |
| [Prompts](/concepts/prompts/) | **Skills**- Project

  Editor Supported aix Adapter

  Path `.agents/skills/prompt-{name}/`

  **aix:** Prompts are installed as instruction-only Agent Skills.

- User

  Editor Supported aix Adapter

  Path `~/.codex/skills/prompt-{name}/`

  **aix:** User-scoped prompts are also converted to skills.                                                                    | **Commands**- Project

  Editor Supported aix Native

  Path `.gemini/commands/*.toml`

- User

  Editor Supported aix Native

  Path `~/.gemini/commands/*.toml` |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix does not yet write Codex project MCP config.

- User

  Editor Supported aix Native

  Path `~/.codex/config.toml`                                                                                                                | **MCP servers**- Project

  Editor Supported aix Native

  Path `.gemini/settings.json`

- User

  Editor Supported aix Native

  Path `~/.gemini/settings.json`  |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.agents/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.codex/skills/{name}/`                                                                                                                                                                                                                      | **Skills**- Project

  Editor Supported aix Native

  Path `.gemini/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.gemini/skills/{name}/`     |
| Agents                        | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Codex.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Codex. | **Subagents**- Project

  Editor Supported aix Native

  Path `.gemini/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.gemini/agents/*.md`        |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.codex/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.codex/hooks.json`                                                                                                                                                                                                                                | **Hooks**- Project

  Editor Supported aix Native

  Path `.gemini/settings.json`

- User

  Editor Supported aix Native

  Path `~/.gemini/settings.json`        |

## Recommended follow-up links

* [Codex support details](/editors/codex/)
* [Gemini support details](/editors/gemini/)
* [All guides that start from Codex](/editors/migrations/#codex)
* [Gemini to Codex](/editors/migrations/how-to-migrate-from-gemini-to-codex/)

---

# How to migrate from Codex to OpenCode

> Compare Codex to OpenCode, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Codex to OpenCode, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync codex --to opencode` copies the supported config from Codex into OpenCode. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Codex                                                                                                                                                                                                                                                                                                                                                                             | OpenCode                                                                                                                                                                                                                                                                                                                                                             |
| ----------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **AGENTS.md**- Project

  Editor Supported aix Native

  Path `AGENTS.md at the project root and selected subdirectories`

- User

  Editor Supported aix Native

  Path `~/.codex/AGENTS.md`                                                                                                                                                                                     | **AGENTS.md**- Project

  Editor Supported aix Native

  Path `AGENTS.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/AGENTS.md`                                                                                                                                                                                                              |
| [Prompts](/concepts/prompts/) | **Skills**- Project

  Editor Supported aix Adapter

  Path `.agents/skills/prompt-{name}/`

  **aix:** Prompts are installed as instruction-only Agent Skills.

- User

  Editor Supported aix Adapter

  Path `~/.codex/skills/prompt-{name}/`

  **aix:** User-scoped prompts are also converted to skills.                                                                    | **Commands**- Project

  Editor Supported aix Native

  Path `.opencode/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/commands/*.md`                                                                                                                                                                                             |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix does not yet write Codex project MCP config.

- User

  Editor Supported aix Native

  Path `~/.codex/config.toml`                                                                                                                | **MCP servers**- Project

  Editor Supported aix Native

  Path `opencode.json`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/opencode.json`                                                                                                                                                                                                    |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.agents/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.codex/skills/{name}/`                                                                                                                                                                                                                      | **Skills**- Project

  Editor Supported aix Native

  Path `.opencode/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/skills/{name}/`                                                                                                                                                                                             |
| Agents                        | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Codex.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Codex. | **Agents**- Project

  Editor Supported aix Native

  Path `.opencode/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/agents/*.md`                                                                                                                                                                                                   |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.codex/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.codex/hooks.json`                                                                                                                                                                                                                                | **Hooks**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** OpenCode does not support lifecycle hooks in aix.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** OpenCode does not support lifecycle hooks in aix. |

## Recommended follow-up links

* [Codex support details](/editors/codex/)
* [OpenCode support details](/editors/opencode/)
* [All guides that start from Codex](/editors/migrations/#codex)
* [OpenCode to Codex](/editors/migrations/how-to-migrate-from-opencode-to-codex/)

---

# How to migrate from Codex to Windsurf

> Compare Codex to Windsurf, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Codex to Windsurf, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync codex --to windsurf` copies the supported config from Codex into Windsurf. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Codex                                                                                                                                                                                                                                                                                                                                                                             | Windsurf                                                                                                                                                                                                                                                                                                                                                                                |
| ----------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **AGENTS.md**- Project

  Editor Supported aix Native

  Path `AGENTS.md at the project root and selected subdirectories`

- User

  Editor Supported aix Native

  Path `~/.codex/AGENTS.md`                                                                                                                                                                                     | **Rules**- Project

  Editor Supported aix Native

  Path `.windsurf/rules/*.md`

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/memories/global_rules.md`                                                                                                                                                                                                          |
| [Prompts](/concepts/prompts/) | **Skills**- Project

  Editor Supported aix Adapter

  Path `.agents/skills/prompt-{name}/`

  **aix:** Prompts are installed as instruction-only Agent Skills.

- User

  Editor Supported aix Adapter

  Path `~/.codex/skills/prompt-{name}/`

  **aix:** User-scoped prompts are also converted to skills.                                                                    | **Workflows**- Project

  Editor Supported aix Native

  Path `.windsurf/workflows/*.md`

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/global_workflows/*.md`                                                                                                                                                                                                     |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix does not yet write Codex project MCP config.

- User

  Editor Supported aix Native

  Path `~/.codex/config.toml`                                                                                                                | **MCP servers**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Windsurf does not have a project-scoped MCP config file in aix.

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/mcp_config.json`                                                                                        |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.agents/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.codex/skills/{name}/`                                                                                                                                                                                                                      | **Skills**- Project

  Editor Supported aix Native

  Path `.windsurf/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.windsurf/skills/{name}/`                                                                                                                                                                                                                       |
| Agents                        | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Codex.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Codex. | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Windsurf.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Windsurf. |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.codex/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.codex/hooks.json`                                                                                                                                                                                                                                | **Hooks**- Project

  Editor Supported aix Native

  Path `.windsurf/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.windsurf/hooks.json`                                                                                                                                                                                                                                |

## Recommended follow-up links

* [Codex support details](/editors/codex/)
* [Windsurf support details](/editors/windsurf/)
* [All guides that start from Codex](/editors/migrations/#codex)
* [Windsurf to Codex](/editors/migrations/how-to-migrate-from-windsurf-to-codex/)

---

# How to migrate from Codex to Zed

> Compare Codex to Zed, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Codex to Zed, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync codex --to zed` copies the supported config from Codex into Zed. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Codex                                                                                                                                                                                                                                                                                                                                                                             | Zed                                                                                                                                                                                                                                                                                                                                                                           |
| ----------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **AGENTS.md**- Project

  Editor Supported aix Native

  Path `AGENTS.md at the project root and selected subdirectories`

- User

  Editor Supported aix Native

  Path `~/.codex/AGENTS.md`                                                                                                                                                                                     | **Rules**- Project

  Editor Supported aix Native

  Path `.rules`

- User

  Editor Supported aix Native

  Path `~/.config/zed/AGENTS.md`                                                                                                                                                                                                                                   |
| [Prompts](/concepts/prompts/) | **Skills**- Project

  Editor Supported aix Adapter

  Path `.agents/skills/prompt-{name}/`

  **aix:** Prompts are installed as instruction-only Agent Skills.

- User

  Editor Supported aix Adapter

  Path `~/.codex/skills/prompt-{name}/`

  **aix:** User-scoped prompts are also converted to skills.                                                                    | **Agent Skills (converted)**- Project

  Editor Supported aix Adapter

  Path `.agents/skills/`

  **aix:** aix converts prompts to Agent Skills in `.agents/skills/<name>/`.

- User

  Editor Supported aix Adapter

  Path `~/.agents/skills/`

  **aix:** aix converts prompts to Agent Skills in `~/.agents/skills/<name>/`.                                             |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix does not yet write Codex project MCP config.

- User

  Editor Supported aix Native

  Path `~/.codex/config.toml`                                                                                                                | **Context servers**- Project

  Editor Supported aix Native

  Path `.zed/settings.json`

- User

  Editor Supported aix Native

  Path `~/.config/zed/settings.json`                                                                                                                                                                                                         |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.agents/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.codex/skills/{name}/`                                                                                                                                                                                                                      | **Agent Skills**- Project

  Editor Supported aix Native

  Path `.agents/skills/`

- User

  Editor Supported aix Native

  Path `~/.agents/skills/`                                                                                                                                                                                                                         |
| Agents                        | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Codex.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Codex. | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Zed.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Zed. |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.codex/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.codex/hooks.json`                                                                                                                                                                                                                                | **Hooks**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Zed does not support lifecycle hooks in aix.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Zed does not support lifecycle hooks in aix.                    |

## Recommended follow-up links

* [Codex support details](/editors/codex/)
* [Zed support details](/editors/zed/)
* [All guides that start from Codex](/editors/migrations/#codex)
* [Zed to Codex](/editors/migrations/how-to-migrate-from-zed-to-codex/)

---

# How to migrate from GitHub Copilot to Claude Code

> Compare GitHub Copilot to Claude Code, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from GitHub Copilot to Claude Code, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync copilot --to claude-code` copies the supported config from GitHub Copilot into Claude Code. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | GitHub Copilot                                                                                                                                                                                                                                                                                                        | Claude Code                                                                                                                                                   |
| ----------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **Instructions**- Project

  Editor Supported aix Native

  Path `.github/instructions/*.instructions.md`

- User

  Editor Supported aix No support

  Editor target `~/.config/github-copilot/instructions/*.instructions.md`

  **aix:** aix does not yet write user-scope Copilot instructions as separate files. | **Rules**- Project

  Editor Supported aix Native

  Path `.claude/rules/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/CLAUDE.md`           |
| [Prompts](/concepts/prompts/) | **Prompt files**- Project

  Editor Supported aix Native

  Path `.github/prompts/*.prompt.md`

- User

  Editor Supported aix Adapter

  Path `~/.config/github-copilot/skills/{name}/`

  **aix:** aix converts user-scope prompts into instruction-only Copilot skills.                                            | **Commands**- Project

  Editor Supported aix Native

  Path `.claude/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/commands/*.md` |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor Supported aix Native

  Path `.mcp.json`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/mcp-config.json`                                                                                                                                                 | **MCP servers**- Project

  Editor Supported aix Native

  Path `.mcp.json`

- User

  Editor Supported aix Native

  Path `~/.claude.json`                   |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.github/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/skills/{name}/`                                                                                                                                          | **Skills**- Project

  Editor Supported aix Native

  Path `.claude/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.claude/skills/{name}/` |
| Agents                        | **Agents**- Project

  Editor Supported aix Native

  Path `.github/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/agents/*.md`                                                                                                                                                | **Subagents**- Project

  Editor Supported aix Native

  Path `.claude/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/agents/*.md`    |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.github/hooks/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/hooks/hooks.json`                                                                                                                                       | **Hooks**- Project

  Editor Supported aix Native

  Path `.claude/settings.json`

- User

  Editor Supported aix Native

  Path `~/.claude/settings.json`    |

## Recommended follow-up links

* [GitHub Copilot support details](/editors/copilot/)
* [Claude Code support details](/editors/claude-code/)
* [All guides that start from GitHub Copilot](/editors/migrations/#copilot)
* [Claude Code to GitHub Copilot](/editors/migrations/how-to-migrate-from-claude-code-to-copilot/)

---

# How to migrate from GitHub Copilot to Codex

> Compare GitHub Copilot to Codex, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from GitHub Copilot to Codex, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync copilot --to codex` copies the supported config from GitHub Copilot into Codex. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | GitHub Copilot                                                                                                                                                                                                                                                                                                        | Codex                                                                                                                                                                                                                                                                                                                                                                             |
| ----------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **Instructions**- Project

  Editor Supported aix Native

  Path `.github/instructions/*.instructions.md`

- User

  Editor Supported aix No support

  Editor target `~/.config/github-copilot/instructions/*.instructions.md`

  **aix:** aix does not yet write user-scope Copilot instructions as separate files. | **AGENTS.md**- Project

  Editor Supported aix Native

  Path `AGENTS.md at the project root and selected subdirectories`

- User

  Editor Supported aix Native

  Path `~/.codex/AGENTS.md`                                                                                                                                                                                     |
| [Prompts](/concepts/prompts/) | **Prompt files**- Project

  Editor Supported aix Native

  Path `.github/prompts/*.prompt.md`

- User

  Editor Supported aix Adapter

  Path `~/.config/github-copilot/skills/{name}/`

  **aix:** aix converts user-scope prompts into instruction-only Copilot skills.                                            | **Skills**- Project

  Editor Supported aix Adapter

  Path `.agents/skills/prompt-{name}/`

  **aix:** Prompts are installed as instruction-only Agent Skills.

- User

  Editor Supported aix Adapter

  Path `~/.codex/skills/prompt-{name}/`

  **aix:** User-scoped prompts are also converted to skills.                                                                    |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor Supported aix Native

  Path `.mcp.json`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/mcp-config.json`                                                                                                                                                 | **MCP servers**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix does not yet write Codex project MCP config.

- User

  Editor Supported aix Native

  Path `~/.codex/config.toml`                                                                                                                |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.github/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/skills/{name}/`                                                                                                                                          | **Skills**- Project

  Editor Supported aix Native

  Path `.agents/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.codex/skills/{name}/`                                                                                                                                                                                                                      |
| Agents                        | **Agents**- Project

  Editor Supported aix Native

  Path `.github/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/agents/*.md`                                                                                                                                                | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Codex.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Codex. |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.github/hooks/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/hooks/hooks.json`                                                                                                                                       | **Hooks**- Project

  Editor Supported aix Native

  Path `.codex/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.codex/hooks.json`                                                                                                                                                                                                                                |

## Recommended follow-up links

* [GitHub Copilot support details](/editors/copilot/)
* [Codex support details](/editors/codex/)
* [All guides that start from GitHub Copilot](/editors/migrations/#copilot)
* [Codex to GitHub Copilot](/editors/migrations/how-to-migrate-from-codex-to-copilot/)

---

# How to migrate from GitHub Copilot to Cursor

> Compare GitHub Copilot to Cursor, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from GitHub Copilot to Cursor, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync copilot --to cursor` copies the supported config from GitHub Copilot into Cursor. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | GitHub Copilot                                                                                                                                                                                                                                                                                                        | Cursor                                                                                                                                                                                                                                                                                                     |
| ----------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **Instructions**- Project

  Editor Supported aix Native

  Path `.github/instructions/*.instructions.md`

- User

  Editor Supported aix No support

  Editor target `~/.config/github-copilot/instructions/*.instructions.md`

  **aix:** aix does not yet write user-scope Copilot instructions as separate files. | **Rules**- Project

  Editor Supported aix Native

  Path `.cursor/rules/*.mdc`

- User

  Editor Supported aix No support

  Editor target `Settings UI`

  **Editor:** Cursor stores user rules in the Settings UI rather than a writable file. **aix:** aix does not currently write Cursor user rules. |
| [Prompts](/concepts/prompts/) | **Prompt files**- Project

  Editor Supported aix Native

  Path `.github/prompts/*.prompt.md`

- User

  Editor Supported aix Adapter

  Path `~/.config/github-copilot/skills/{name}/`

  **aix:** aix converts user-scope prompts into instruction-only Copilot skills.                                            | **Commands**- Project

  Editor Supported aix Native

  Path `.cursor/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.cursor/commands/*.md`                                                                                                                                              |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor Supported aix Native

  Path `.mcp.json`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/mcp-config.json`                                                                                                                                                 | **MCP servers**- Project

  Editor Supported aix Native

  Path `.cursor/mcp.json`

- User

  Editor Supported aix Native

  Path `~/.cursor/mcp.json`                                                                                                                                                     |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.github/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/skills/{name}/`                                                                                                                                          | **Skills**- Project

  Editor Supported aix Native

  Path `.cursor/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.cursor/skills/{name}/`                                                                                                                                              |
| Agents                        | **Agents**- Project

  Editor Supported aix Native

  Path `.github/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/agents/*.md`                                                                                                                                                | **Agents**- Project

  Editor Supported aix Native

  Path `.cursor/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.cursor/agents/*.md`                                                                                                                                                    |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.github/hooks/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/hooks/hooks.json`                                                                                                                                       | **Hooks**- Project

  Editor Supported aix Native

  Path `.cursor/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.cursor/hooks.json`                                                                                                                                                       |

## Recommended follow-up links

* [GitHub Copilot support details](/editors/copilot/)
* [Cursor support details](/editors/cursor/)
* [All guides that start from GitHub Copilot](/editors/migrations/#copilot)
* [Cursor to GitHub Copilot](/editors/migrations/how-to-migrate-from-cursor-to-copilot/)

---

# How to migrate from GitHub Copilot to Gemini

> Compare GitHub Copilot to Gemini, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from GitHub Copilot to Gemini, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync copilot --to gemini` copies the supported config from GitHub Copilot into Gemini. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | GitHub Copilot                                                                                                                                                                                                                                                                                                        | Gemini                                                                                                                                                            |
| ----------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **Instructions**- Project

  Editor Supported aix Native

  Path `.github/instructions/*.instructions.md`

- User

  Editor Supported aix No support

  Editor target `~/.config/github-copilot/instructions/*.instructions.md`

  **aix:** aix does not yet write user-scope Copilot instructions as separate files. | **GEMINI.md**- Project

  Editor Supported aix Native

  Path `GEMINI.md`

- User

  Editor Supported aix Native

  Path `~/.gemini/GEMINI.md`                    |
| [Prompts](/concepts/prompts/) | **Prompt files**- Project

  Editor Supported aix Native

  Path `.github/prompts/*.prompt.md`

- User

  Editor Supported aix Adapter

  Path `~/.config/github-copilot/skills/{name}/`

  **aix:** aix converts user-scope prompts into instruction-only Copilot skills.                                            | **Commands**- Project

  Editor Supported aix Native

  Path `.gemini/commands/*.toml`

- User

  Editor Supported aix Native

  Path `~/.gemini/commands/*.toml` |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor Supported aix Native

  Path `.mcp.json`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/mcp-config.json`                                                                                                                                                 | **MCP servers**- Project

  Editor Supported aix Native

  Path `.gemini/settings.json`

- User

  Editor Supported aix Native

  Path `~/.gemini/settings.json`  |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.github/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/skills/{name}/`                                                                                                                                          | **Skills**- Project

  Editor Supported aix Native

  Path `.gemini/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.gemini/skills/{name}/`     |
| Agents                        | **Agents**- Project

  Editor Supported aix Native

  Path `.github/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/agents/*.md`                                                                                                                                                | **Subagents**- Project

  Editor Supported aix Native

  Path `.gemini/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.gemini/agents/*.md`        |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.github/hooks/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/hooks/hooks.json`                                                                                                                                       | **Hooks**- Project

  Editor Supported aix Native

  Path `.gemini/settings.json`

- User

  Editor Supported aix Native

  Path `~/.gemini/settings.json`        |

## Recommended follow-up links

* [GitHub Copilot support details](/editors/copilot/)
* [Gemini support details](/editors/gemini/)
* [All guides that start from GitHub Copilot](/editors/migrations/#copilot)
* [Gemini to GitHub Copilot](/editors/migrations/how-to-migrate-from-gemini-to-copilot/)

---

# How to migrate from GitHub Copilot to OpenCode

> Compare GitHub Copilot to OpenCode, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from GitHub Copilot to OpenCode, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync copilot --to opencode` copies the supported config from GitHub Copilot into OpenCode. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | GitHub Copilot                                                                                                                                                                                                                                                                                                        | OpenCode                                                                                                                                                                                                                                                                                                                                                             |
| ----------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **Instructions**- Project

  Editor Supported aix Native

  Path `.github/instructions/*.instructions.md`

- User

  Editor Supported aix No support

  Editor target `~/.config/github-copilot/instructions/*.instructions.md`

  **aix:** aix does not yet write user-scope Copilot instructions as separate files. | **AGENTS.md**- Project

  Editor Supported aix Native

  Path `AGENTS.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/AGENTS.md`                                                                                                                                                                                                              |
| [Prompts](/concepts/prompts/) | **Prompt files**- Project

  Editor Supported aix Native

  Path `.github/prompts/*.prompt.md`

- User

  Editor Supported aix Adapter

  Path `~/.config/github-copilot/skills/{name}/`

  **aix:** aix converts user-scope prompts into instruction-only Copilot skills.                                            | **Commands**- Project

  Editor Supported aix Native

  Path `.opencode/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/commands/*.md`                                                                                                                                                                                             |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor Supported aix Native

  Path `.mcp.json`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/mcp-config.json`                                                                                                                                                 | **MCP servers**- Project

  Editor Supported aix Native

  Path `opencode.json`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/opencode.json`                                                                                                                                                                                                    |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.github/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/skills/{name}/`                                                                                                                                          | **Skills**- Project

  Editor Supported aix Native

  Path `.opencode/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/skills/{name}/`                                                                                                                                                                                             |
| Agents                        | **Agents**- Project

  Editor Supported aix Native

  Path `.github/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/agents/*.md`                                                                                                                                                | **Agents**- Project

  Editor Supported aix Native

  Path `.opencode/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/agents/*.md`                                                                                                                                                                                                   |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.github/hooks/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/hooks/hooks.json`                                                                                                                                       | **Hooks**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** OpenCode does not support lifecycle hooks in aix.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** OpenCode does not support lifecycle hooks in aix. |

## Recommended follow-up links

* [GitHub Copilot support details](/editors/copilot/)
* [OpenCode support details](/editors/opencode/)
* [All guides that start from GitHub Copilot](/editors/migrations/#copilot)
* [OpenCode to GitHub Copilot](/editors/migrations/how-to-migrate-from-opencode-to-copilot/)

---

# How to migrate from GitHub Copilot to Windsurf

> Compare GitHub Copilot to Windsurf, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from GitHub Copilot to Windsurf, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync copilot --to windsurf` copies the supported config from GitHub Copilot into Windsurf. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | GitHub Copilot                                                                                                                                                                                                                                                                                                        | Windsurf                                                                                                                                                                                                                                                                                                                                                                                |
| ----------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **Instructions**- Project

  Editor Supported aix Native

  Path `.github/instructions/*.instructions.md`

- User

  Editor Supported aix No support

  Editor target `~/.config/github-copilot/instructions/*.instructions.md`

  **aix:** aix does not yet write user-scope Copilot instructions as separate files. | **Rules**- Project

  Editor Supported aix Native

  Path `.windsurf/rules/*.md`

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/memories/global_rules.md`                                                                                                                                                                                                          |
| [Prompts](/concepts/prompts/) | **Prompt files**- Project

  Editor Supported aix Native

  Path `.github/prompts/*.prompt.md`

- User

  Editor Supported aix Adapter

  Path `~/.config/github-copilot/skills/{name}/`

  **aix:** aix converts user-scope prompts into instruction-only Copilot skills.                                            | **Workflows**- Project

  Editor Supported aix Native

  Path `.windsurf/workflows/*.md`

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/global_workflows/*.md`                                                                                                                                                                                                     |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor Supported aix Native

  Path `.mcp.json`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/mcp-config.json`                                                                                                                                                 | **MCP servers**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Windsurf does not have a project-scoped MCP config file in aix.

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/mcp_config.json`                                                                                        |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.github/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/skills/{name}/`                                                                                                                                          | **Skills**- Project

  Editor Supported aix Native

  Path `.windsurf/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.windsurf/skills/{name}/`                                                                                                                                                                                                                       |
| Agents                        | **Agents**- Project

  Editor Supported aix Native

  Path `.github/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/agents/*.md`                                                                                                                                                | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Windsurf.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Windsurf. |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.github/hooks/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/hooks/hooks.json`                                                                                                                                       | **Hooks**- Project

  Editor Supported aix Native

  Path `.windsurf/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.windsurf/hooks.json`                                                                                                                                                                                                                                |

## Recommended follow-up links

* [GitHub Copilot support details](/editors/copilot/)
* [Windsurf support details](/editors/windsurf/)
* [All guides that start from GitHub Copilot](/editors/migrations/#copilot)
* [Windsurf to GitHub Copilot](/editors/migrations/how-to-migrate-from-windsurf-to-copilot/)

---

# How to migrate from GitHub Copilot to Zed

> Compare GitHub Copilot to Zed, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from GitHub Copilot to Zed, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync copilot --to zed` copies the supported config from GitHub Copilot into Zed. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | GitHub Copilot                                                                                                                                                                                                                                                                                                        | Zed                                                                                                                                                                                                                                                                                                                                                                           |
| ----------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **Instructions**- Project

  Editor Supported aix Native

  Path `.github/instructions/*.instructions.md`

- User

  Editor Supported aix No support

  Editor target `~/.config/github-copilot/instructions/*.instructions.md`

  **aix:** aix does not yet write user-scope Copilot instructions as separate files. | **Rules**- Project

  Editor Supported aix Native

  Path `.rules`

- User

  Editor Supported aix Native

  Path `~/.config/zed/AGENTS.md`                                                                                                                                                                                                                                   |
| [Prompts](/concepts/prompts/) | **Prompt files**- Project

  Editor Supported aix Native

  Path `.github/prompts/*.prompt.md`

- User

  Editor Supported aix Adapter

  Path `~/.config/github-copilot/skills/{name}/`

  **aix:** aix converts user-scope prompts into instruction-only Copilot skills.                                            | **Agent Skills (converted)**- Project

  Editor Supported aix Adapter

  Path `.agents/skills/`

  **aix:** aix converts prompts to Agent Skills in `.agents/skills/<name>/`.

- User

  Editor Supported aix Adapter

  Path `~/.agents/skills/`

  **aix:** aix converts prompts to Agent Skills in `~/.agents/skills/<name>/`.                                             |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor Supported aix Native

  Path `.mcp.json`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/mcp-config.json`                                                                                                                                                 | **Context servers**- Project

  Editor Supported aix Native

  Path `.zed/settings.json`

- User

  Editor Supported aix Native

  Path `~/.config/zed/settings.json`                                                                                                                                                                                                         |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.github/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/skills/{name}/`                                                                                                                                          | **Agent Skills**- Project

  Editor Supported aix Native

  Path `.agents/skills/`

- User

  Editor Supported aix Native

  Path `~/.agents/skills/`                                                                                                                                                                                                                         |
| Agents                        | **Agents**- Project

  Editor Supported aix Native

  Path `.github/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/agents/*.md`                                                                                                                                                | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Zed.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Zed. |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.github/hooks/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/hooks/hooks.json`                                                                                                                                       | **Hooks**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Zed does not support lifecycle hooks in aix.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Zed does not support lifecycle hooks in aix.                    |

## Recommended follow-up links

* [GitHub Copilot support details](/editors/copilot/)
* [Zed support details](/editors/zed/)
* [All guides that start from GitHub Copilot](/editors/migrations/#copilot)
* [Zed to GitHub Copilot](/editors/migrations/how-to-migrate-from-zed-to-copilot/)

---

# How to migrate from Cursor to Claude Code

> Compare Cursor to Claude Code, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Cursor to Claude Code, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync cursor --to claude-code` copies the supported config from Cursor into Claude Code. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Cursor                                                                                                                                                                                                                                                                                                     | Claude Code                                                                                                                                                   |
| ----------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **Rules**- Project

  Editor Supported aix Native

  Path `.cursor/rules/*.mdc`

- User

  Editor Supported aix No support

  Editor target `Settings UI`

  **Editor:** Cursor stores user rules in the Settings UI rather than a writable file. **aix:** aix does not currently write Cursor user rules. | **Rules**- Project

  Editor Supported aix Native

  Path `.claude/rules/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/CLAUDE.md`           |
| [Prompts](/concepts/prompts/) | **Commands**- Project

  Editor Supported aix Native

  Path `.cursor/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.cursor/commands/*.md`                                                                                                                                              | **Commands**- Project

  Editor Supported aix Native

  Path `.claude/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/commands/*.md` |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor Supported aix Native

  Path `.cursor/mcp.json`

- User

  Editor Supported aix Native

  Path `~/.cursor/mcp.json`                                                                                                                                                     | **MCP servers**- Project

  Editor Supported aix Native

  Path `.mcp.json`

- User

  Editor Supported aix Native

  Path `~/.claude.json`                   |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.cursor/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.cursor/skills/{name}/`                                                                                                                                              | **Skills**- Project

  Editor Supported aix Native

  Path `.claude/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.claude/skills/{name}/` |
| Agents                        | **Agents**- Project

  Editor Supported aix Native

  Path `.cursor/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.cursor/agents/*.md`                                                                                                                                                    | **Subagents**- Project

  Editor Supported aix Native

  Path `.claude/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/agents/*.md`    |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.cursor/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.cursor/hooks.json`                                                                                                                                                       | **Hooks**- Project

  Editor Supported aix Native

  Path `.claude/settings.json`

- User

  Editor Supported aix Native

  Path `~/.claude/settings.json`    |

## Recommended follow-up links

* [Cursor support details](/editors/cursor/)
* [Claude Code support details](/editors/claude-code/)
* [All guides that start from Cursor](/editors/migrations/#cursor)
* [Claude Code to Cursor](/editors/migrations/how-to-migrate-from-claude-code-to-cursor/)

---

# How to migrate from Cursor to Codex

> Compare Cursor to Codex, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Cursor to Codex, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync cursor --to codex` copies the supported config from Cursor into Codex. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Cursor                                                                                                                                                                                                                                                                                                     | Codex                                                                                                                                                                                                                                                                                                                                                                             |
| ----------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **Rules**- Project

  Editor Supported aix Native

  Path `.cursor/rules/*.mdc`

- User

  Editor Supported aix No support

  Editor target `Settings UI`

  **Editor:** Cursor stores user rules in the Settings UI rather than a writable file. **aix:** aix does not currently write Cursor user rules. | **AGENTS.md**- Project

  Editor Supported aix Native

  Path `AGENTS.md at the project root and selected subdirectories`

- User

  Editor Supported aix Native

  Path `~/.codex/AGENTS.md`                                                                                                                                                                                     |
| [Prompts](/concepts/prompts/) | **Commands**- Project

  Editor Supported aix Native

  Path `.cursor/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.cursor/commands/*.md`                                                                                                                                              | **Skills**- Project

  Editor Supported aix Adapter

  Path `.agents/skills/prompt-{name}/`

  **aix:** Prompts are installed as instruction-only Agent Skills.

- User

  Editor Supported aix Adapter

  Path `~/.codex/skills/prompt-{name}/`

  **aix:** User-scoped prompts are also converted to skills.                                                                    |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor Supported aix Native

  Path `.cursor/mcp.json`

- User

  Editor Supported aix Native

  Path `~/.cursor/mcp.json`                                                                                                                                                     | **MCP servers**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix does not yet write Codex project MCP config.

- User

  Editor Supported aix Native

  Path `~/.codex/config.toml`                                                                                                                |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.cursor/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.cursor/skills/{name}/`                                                                                                                                              | **Skills**- Project

  Editor Supported aix Native

  Path `.agents/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.codex/skills/{name}/`                                                                                                                                                                                                                      |
| Agents                        | **Agents**- Project

  Editor Supported aix Native

  Path `.cursor/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.cursor/agents/*.md`                                                                                                                                                    | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Codex.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Codex. |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.cursor/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.cursor/hooks.json`                                                                                                                                                       | **Hooks**- Project

  Editor Supported aix Native

  Path `.codex/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.codex/hooks.json`                                                                                                                                                                                                                                |

## Recommended follow-up links

* [Cursor support details](/editors/cursor/)
* [Codex support details](/editors/codex/)
* [All guides that start from Cursor](/editors/migrations/#cursor)
* [Codex to Cursor](/editors/migrations/how-to-migrate-from-codex-to-cursor/)

---

# How to migrate from Cursor to GitHub Copilot

> Compare Cursor to GitHub Copilot, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Cursor to GitHub Copilot, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync cursor --to copilot` copies the supported config from Cursor into GitHub Copilot. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Cursor                                                                                                                                                                                                                                                                                                     | GitHub Copilot                                                                                                                                                                                                                                                                                                        |
| ----------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **Rules**- Project

  Editor Supported aix Native

  Path `.cursor/rules/*.mdc`

- User

  Editor Supported aix No support

  Editor target `Settings UI`

  **Editor:** Cursor stores user rules in the Settings UI rather than a writable file. **aix:** aix does not currently write Cursor user rules. | **Instructions**- Project

  Editor Supported aix Native

  Path `.github/instructions/*.instructions.md`

- User

  Editor Supported aix No support

  Editor target `~/.config/github-copilot/instructions/*.instructions.md`

  **aix:** aix does not yet write user-scope Copilot instructions as separate files. |
| [Prompts](/concepts/prompts/) | **Commands**- Project

  Editor Supported aix Native

  Path `.cursor/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.cursor/commands/*.md`                                                                                                                                              | **Prompt files**- Project

  Editor Supported aix Native

  Path `.github/prompts/*.prompt.md`

- User

  Editor Supported aix Adapter

  Path `~/.config/github-copilot/skills/{name}/`

  **aix:** aix converts user-scope prompts into instruction-only Copilot skills.                                            |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor Supported aix Native

  Path `.cursor/mcp.json`

- User

  Editor Supported aix Native

  Path `~/.cursor/mcp.json`                                                                                                                                                     | **MCP servers**- Project

  Editor Supported aix Native

  Path `.mcp.json`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/mcp-config.json`                                                                                                                                                 |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.cursor/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.cursor/skills/{name}/`                                                                                                                                              | **Skills**- Project

  Editor Supported aix Native

  Path `.github/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/skills/{name}/`                                                                                                                                          |
| Agents                        | **Agents**- Project

  Editor Supported aix Native

  Path `.cursor/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.cursor/agents/*.md`                                                                                                                                                    | **Agents**- Project

  Editor Supported aix Native

  Path `.github/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/agents/*.md`                                                                                                                                                |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.cursor/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.cursor/hooks.json`                                                                                                                                                       | **Hooks**- Project

  Editor Supported aix Native

  Path `.github/hooks/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/hooks/hooks.json`                                                                                                                                       |

## Recommended follow-up links

* [Cursor support details](/editors/cursor/)
* [GitHub Copilot support details](/editors/copilot/)
* [All guides that start from Cursor](/editors/migrations/#cursor)
* [GitHub Copilot to Cursor](/editors/migrations/how-to-migrate-from-copilot-to-cursor/)

---

# How to migrate from Cursor to Gemini

> Compare Cursor to Gemini, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Cursor to Gemini, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync cursor --to gemini` copies the supported config from Cursor into Gemini. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Cursor                                                                                                                                                                                                                                                                                                     | Gemini                                                                                                                                                            |
| ----------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **Rules**- Project

  Editor Supported aix Native

  Path `.cursor/rules/*.mdc`

- User

  Editor Supported aix No support

  Editor target `Settings UI`

  **Editor:** Cursor stores user rules in the Settings UI rather than a writable file. **aix:** aix does not currently write Cursor user rules. | **GEMINI.md**- Project

  Editor Supported aix Native

  Path `GEMINI.md`

- User

  Editor Supported aix Native

  Path `~/.gemini/GEMINI.md`                    |
| [Prompts](/concepts/prompts/) | **Commands**- Project

  Editor Supported aix Native

  Path `.cursor/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.cursor/commands/*.md`                                                                                                                                              | **Commands**- Project

  Editor Supported aix Native

  Path `.gemini/commands/*.toml`

- User

  Editor Supported aix Native

  Path `~/.gemini/commands/*.toml` |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor Supported aix Native

  Path `.cursor/mcp.json`

- User

  Editor Supported aix Native

  Path `~/.cursor/mcp.json`                                                                                                                                                     | **MCP servers**- Project

  Editor Supported aix Native

  Path `.gemini/settings.json`

- User

  Editor Supported aix Native

  Path `~/.gemini/settings.json`  |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.cursor/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.cursor/skills/{name}/`                                                                                                                                              | **Skills**- Project

  Editor Supported aix Native

  Path `.gemini/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.gemini/skills/{name}/`     |
| Agents                        | **Agents**- Project

  Editor Supported aix Native

  Path `.cursor/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.cursor/agents/*.md`                                                                                                                                                    | **Subagents**- Project

  Editor Supported aix Native

  Path `.gemini/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.gemini/agents/*.md`        |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.cursor/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.cursor/hooks.json`                                                                                                                                                       | **Hooks**- Project

  Editor Supported aix Native

  Path `.gemini/settings.json`

- User

  Editor Supported aix Native

  Path `~/.gemini/settings.json`        |

## Recommended follow-up links

* [Cursor support details](/editors/cursor/)
* [Gemini support details](/editors/gemini/)
* [All guides that start from Cursor](/editors/migrations/#cursor)
* [Gemini to Cursor](/editors/migrations/how-to-migrate-from-gemini-to-cursor/)

---

# How to migrate from Cursor to OpenCode

> Compare Cursor to OpenCode, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Cursor to OpenCode, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync cursor --to opencode` copies the supported config from Cursor into OpenCode. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Cursor                                                                                                                                                                                                                                                                                                     | OpenCode                                                                                                                                                                                                                                                                                                                                                             |
| ----------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **Rules**- Project

  Editor Supported aix Native

  Path `.cursor/rules/*.mdc`

- User

  Editor Supported aix No support

  Editor target `Settings UI`

  **Editor:** Cursor stores user rules in the Settings UI rather than a writable file. **aix:** aix does not currently write Cursor user rules. | **AGENTS.md**- Project

  Editor Supported aix Native

  Path `AGENTS.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/AGENTS.md`                                                                                                                                                                                                              |
| [Prompts](/concepts/prompts/) | **Commands**- Project

  Editor Supported aix Native

  Path `.cursor/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.cursor/commands/*.md`                                                                                                                                              | **Commands**- Project

  Editor Supported aix Native

  Path `.opencode/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/commands/*.md`                                                                                                                                                                                             |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor Supported aix Native

  Path `.cursor/mcp.json`

- User

  Editor Supported aix Native

  Path `~/.cursor/mcp.json`                                                                                                                                                     | **MCP servers**- Project

  Editor Supported aix Native

  Path `opencode.json`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/opencode.json`                                                                                                                                                                                                    |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.cursor/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.cursor/skills/{name}/`                                                                                                                                              | **Skills**- Project

  Editor Supported aix Native

  Path `.opencode/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/skills/{name}/`                                                                                                                                                                                             |
| Agents                        | **Agents**- Project

  Editor Supported aix Native

  Path `.cursor/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.cursor/agents/*.md`                                                                                                                                                    | **Agents**- Project

  Editor Supported aix Native

  Path `.opencode/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/agents/*.md`                                                                                                                                                                                                   |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.cursor/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.cursor/hooks.json`                                                                                                                                                       | **Hooks**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** OpenCode does not support lifecycle hooks in aix.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** OpenCode does not support lifecycle hooks in aix. |

## Recommended follow-up links

* [Cursor support details](/editors/cursor/)
* [OpenCode support details](/editors/opencode/)
* [All guides that start from Cursor](/editors/migrations/#cursor)
* [OpenCode to Cursor](/editors/migrations/how-to-migrate-from-opencode-to-cursor/)

---

# How to migrate from Cursor to Windsurf

> Compare Cursor to Windsurf, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Cursor to Windsurf, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync cursor --to windsurf` copies the supported config from Cursor into Windsurf. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Cursor                                                                                                                                                                                                                                                                                                     | Windsurf                                                                                                                                                                                                                                                                                                                                                                                |
| ----------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **Rules**- Project

  Editor Supported aix Native

  Path `.cursor/rules/*.mdc`

- User

  Editor Supported aix No support

  Editor target `Settings UI`

  **Editor:** Cursor stores user rules in the Settings UI rather than a writable file. **aix:** aix does not currently write Cursor user rules. | **Rules**- Project

  Editor Supported aix Native

  Path `.windsurf/rules/*.md`

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/memories/global_rules.md`                                                                                                                                                                                                          |
| [Prompts](/concepts/prompts/) | **Commands**- Project

  Editor Supported aix Native

  Path `.cursor/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.cursor/commands/*.md`                                                                                                                                              | **Workflows**- Project

  Editor Supported aix Native

  Path `.windsurf/workflows/*.md`

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/global_workflows/*.md`                                                                                                                                                                                                     |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor Supported aix Native

  Path `.cursor/mcp.json`

- User

  Editor Supported aix Native

  Path `~/.cursor/mcp.json`                                                                                                                                                     | **MCP servers**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Windsurf does not have a project-scoped MCP config file in aix.

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/mcp_config.json`                                                                                        |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.cursor/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.cursor/skills/{name}/`                                                                                                                                              | **Skills**- Project

  Editor Supported aix Native

  Path `.windsurf/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.windsurf/skills/{name}/`                                                                                                                                                                                                                       |
| Agents                        | **Agents**- Project

  Editor Supported aix Native

  Path `.cursor/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.cursor/agents/*.md`                                                                                                                                                    | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Windsurf.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Windsurf. |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.cursor/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.cursor/hooks.json`                                                                                                                                                       | **Hooks**- Project

  Editor Supported aix Native

  Path `.windsurf/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.windsurf/hooks.json`                                                                                                                                                                                                                                |

## Recommended follow-up links

* [Cursor support details](/editors/cursor/)
* [Windsurf support details](/editors/windsurf/)
* [All guides that start from Cursor](/editors/migrations/#cursor)
* [Windsurf to Cursor](/editors/migrations/how-to-migrate-from-windsurf-to-cursor/)

---

# How to migrate from Cursor to Zed

> Compare Cursor to Zed, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Cursor to Zed, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync cursor --to zed` copies the supported config from Cursor into Zed. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Cursor                                                                                                                                                                                                                                                                                                     | Zed                                                                                                                                                                                                                                                                                                                                                                           |
| ----------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **Rules**- Project

  Editor Supported aix Native

  Path `.cursor/rules/*.mdc`

- User

  Editor Supported aix No support

  Editor target `Settings UI`

  **Editor:** Cursor stores user rules in the Settings UI rather than a writable file. **aix:** aix does not currently write Cursor user rules. | **Rules**- Project

  Editor Supported aix Native

  Path `.rules`

- User

  Editor Supported aix Native

  Path `~/.config/zed/AGENTS.md`                                                                                                                                                                                                                                   |
| [Prompts](/concepts/prompts/) | **Commands**- Project

  Editor Supported aix Native

  Path `.cursor/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.cursor/commands/*.md`                                                                                                                                              | **Agent Skills (converted)**- Project

  Editor Supported aix Adapter

  Path `.agents/skills/`

  **aix:** aix converts prompts to Agent Skills in `.agents/skills/<name>/`.

- User

  Editor Supported aix Adapter

  Path `~/.agents/skills/`

  **aix:** aix converts prompts to Agent Skills in `~/.agents/skills/<name>/`.                                             |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor Supported aix Native

  Path `.cursor/mcp.json`

- User

  Editor Supported aix Native

  Path `~/.cursor/mcp.json`                                                                                                                                                     | **Context servers**- Project

  Editor Supported aix Native

  Path `.zed/settings.json`

- User

  Editor Supported aix Native

  Path `~/.config/zed/settings.json`                                                                                                                                                                                                         |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.cursor/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.cursor/skills/{name}/`                                                                                                                                              | **Agent Skills**- Project

  Editor Supported aix Native

  Path `.agents/skills/`

- User

  Editor Supported aix Native

  Path `~/.agents/skills/`                                                                                                                                                                                                                         |
| Agents                        | **Agents**- Project

  Editor Supported aix Native

  Path `.cursor/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.cursor/agents/*.md`                                                                                                                                                    | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Zed.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Zed. |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.cursor/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.cursor/hooks.json`                                                                                                                                                       | **Hooks**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Zed does not support lifecycle hooks in aix.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Zed does not support lifecycle hooks in aix.                    |

## Recommended follow-up links

* [Cursor support details](/editors/cursor/)
* [Zed support details](/editors/zed/)
* [All guides that start from Cursor](/editors/migrations/#cursor)
* [Zed to Cursor](/editors/migrations/how-to-migrate-from-zed-to-cursor/)

---

# How to migrate from Gemini to Claude Code

> Compare Gemini to Claude Code, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Gemini to Claude Code, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync gemini --to claude-code` copies the supported config from Gemini into Claude Code. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Gemini                                                                                                                                                            | Claude Code                                                                                                                                                   |
| ----------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **GEMINI.md**- Project

  Editor Supported aix Native

  Path `GEMINI.md`

- User

  Editor Supported aix Native

  Path `~/.gemini/GEMINI.md`                    | **Rules**- Project

  Editor Supported aix Native

  Path `.claude/rules/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/CLAUDE.md`           |
| [Prompts](/concepts/prompts/) | **Commands**- Project

  Editor Supported aix Native

  Path `.gemini/commands/*.toml`

- User

  Editor Supported aix Native

  Path `~/.gemini/commands/*.toml` | **Commands**- Project

  Editor Supported aix Native

  Path `.claude/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/commands/*.md` |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor Supported aix Native

  Path `.gemini/settings.json`

- User

  Editor Supported aix Native

  Path `~/.gemini/settings.json`  | **MCP servers**- Project

  Editor Supported aix Native

  Path `.mcp.json`

- User

  Editor Supported aix Native

  Path `~/.claude.json`                   |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.gemini/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.gemini/skills/{name}/`     | **Skills**- Project

  Editor Supported aix Native

  Path `.claude/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.claude/skills/{name}/` |
| Agents                        | **Subagents**- Project

  Editor Supported aix Native

  Path `.gemini/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.gemini/agents/*.md`        | **Subagents**- Project

  Editor Supported aix Native

  Path `.claude/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/agents/*.md`    |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.gemini/settings.json`

- User

  Editor Supported aix Native

  Path `~/.gemini/settings.json`        | **Hooks**- Project

  Editor Supported aix Native

  Path `.claude/settings.json`

- User

  Editor Supported aix Native

  Path `~/.claude/settings.json`    |

## Recommended follow-up links

* [Gemini support details](/editors/gemini/)
* [Claude Code support details](/editors/claude-code/)
* [All guides that start from Gemini](/editors/migrations/#gemini)
* [Claude Code to Gemini](/editors/migrations/how-to-migrate-from-claude-code-to-gemini/)

---

# How to migrate from Gemini to Codex

> Compare Gemini to Codex, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Gemini to Codex, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync gemini --to codex` copies the supported config from Gemini into Codex. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Gemini                                                                                                                                                            | Codex                                                                                                                                                                                                                                                                                                                                                                             |
| ----------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **GEMINI.md**- Project

  Editor Supported aix Native

  Path `GEMINI.md`

- User

  Editor Supported aix Native

  Path `~/.gemini/GEMINI.md`                    | **AGENTS.md**- Project

  Editor Supported aix Native

  Path `AGENTS.md at the project root and selected subdirectories`

- User

  Editor Supported aix Native

  Path `~/.codex/AGENTS.md`                                                                                                                                                                                     |
| [Prompts](/concepts/prompts/) | **Commands**- Project

  Editor Supported aix Native

  Path `.gemini/commands/*.toml`

- User

  Editor Supported aix Native

  Path `~/.gemini/commands/*.toml` | **Skills**- Project

  Editor Supported aix Adapter

  Path `.agents/skills/prompt-{name}/`

  **aix:** Prompts are installed as instruction-only Agent Skills.

- User

  Editor Supported aix Adapter

  Path `~/.codex/skills/prompt-{name}/`

  **aix:** User-scoped prompts are also converted to skills.                                                                    |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor Supported aix Native

  Path `.gemini/settings.json`

- User

  Editor Supported aix Native

  Path `~/.gemini/settings.json`  | **MCP servers**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix does not yet write Codex project MCP config.

- User

  Editor Supported aix Native

  Path `~/.codex/config.toml`                                                                                                                |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.gemini/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.gemini/skills/{name}/`     | **Skills**- Project

  Editor Supported aix Native

  Path `.agents/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.codex/skills/{name}/`                                                                                                                                                                                                                      |
| Agents                        | **Subagents**- Project

  Editor Supported aix Native

  Path `.gemini/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.gemini/agents/*.md`        | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Codex.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Codex. |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.gemini/settings.json`

- User

  Editor Supported aix Native

  Path `~/.gemini/settings.json`        | **Hooks**- Project

  Editor Supported aix Native

  Path `.codex/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.codex/hooks.json`                                                                                                                                                                                                                                |

## Recommended follow-up links

* [Gemini support details](/editors/gemini/)
* [Codex support details](/editors/codex/)
* [All guides that start from Gemini](/editors/migrations/#gemini)
* [Codex to Gemini](/editors/migrations/how-to-migrate-from-codex-to-gemini/)

---

# How to migrate from Gemini to GitHub Copilot

> Compare Gemini to GitHub Copilot, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Gemini to GitHub Copilot, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync gemini --to copilot` copies the supported config from Gemini into GitHub Copilot. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Gemini                                                                                                                                                            | GitHub Copilot                                                                                                                                                                                                                                                                                                        |
| ----------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **GEMINI.md**- Project

  Editor Supported aix Native

  Path `GEMINI.md`

- User

  Editor Supported aix Native

  Path `~/.gemini/GEMINI.md`                    | **Instructions**- Project

  Editor Supported aix Native

  Path `.github/instructions/*.instructions.md`

- User

  Editor Supported aix No support

  Editor target `~/.config/github-copilot/instructions/*.instructions.md`

  **aix:** aix does not yet write user-scope Copilot instructions as separate files. |
| [Prompts](/concepts/prompts/) | **Commands**- Project

  Editor Supported aix Native

  Path `.gemini/commands/*.toml`

- User

  Editor Supported aix Native

  Path `~/.gemini/commands/*.toml` | **Prompt files**- Project

  Editor Supported aix Native

  Path `.github/prompts/*.prompt.md`

- User

  Editor Supported aix Adapter

  Path `~/.config/github-copilot/skills/{name}/`

  **aix:** aix converts user-scope prompts into instruction-only Copilot skills.                                            |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor Supported aix Native

  Path `.gemini/settings.json`

- User

  Editor Supported aix Native

  Path `~/.gemini/settings.json`  | **MCP servers**- Project

  Editor Supported aix Native

  Path `.mcp.json`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/mcp-config.json`                                                                                                                                                 |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.gemini/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.gemini/skills/{name}/`     | **Skills**- Project

  Editor Supported aix Native

  Path `.github/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/skills/{name}/`                                                                                                                                          |
| Agents                        | **Subagents**- Project

  Editor Supported aix Native

  Path `.gemini/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.gemini/agents/*.md`        | **Agents**- Project

  Editor Supported aix Native

  Path `.github/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/agents/*.md`                                                                                                                                                |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.gemini/settings.json`

- User

  Editor Supported aix Native

  Path `~/.gemini/settings.json`        | **Hooks**- Project

  Editor Supported aix Native

  Path `.github/hooks/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/hooks/hooks.json`                                                                                                                                       |

## Recommended follow-up links

* [Gemini support details](/editors/gemini/)
* [GitHub Copilot support details](/editors/copilot/)
* [All guides that start from Gemini](/editors/migrations/#gemini)
* [GitHub Copilot to Gemini](/editors/migrations/how-to-migrate-from-copilot-to-gemini/)

---

# How to migrate from Gemini to Cursor

> Compare Gemini to Cursor, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Gemini to Cursor, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync gemini --to cursor` copies the supported config from Gemini into Cursor. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Gemini                                                                                                                                                            | Cursor                                                                                                                                                                                                                                                                                                     |
| ----------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **GEMINI.md**- Project

  Editor Supported aix Native

  Path `GEMINI.md`

- User

  Editor Supported aix Native

  Path `~/.gemini/GEMINI.md`                    | **Rules**- Project

  Editor Supported aix Native

  Path `.cursor/rules/*.mdc`

- User

  Editor Supported aix No support

  Editor target `Settings UI`

  **Editor:** Cursor stores user rules in the Settings UI rather than a writable file. **aix:** aix does not currently write Cursor user rules. |
| [Prompts](/concepts/prompts/) | **Commands**- Project

  Editor Supported aix Native

  Path `.gemini/commands/*.toml`

- User

  Editor Supported aix Native

  Path `~/.gemini/commands/*.toml` | **Commands**- Project

  Editor Supported aix Native

  Path `.cursor/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.cursor/commands/*.md`                                                                                                                                              |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor Supported aix Native

  Path `.gemini/settings.json`

- User

  Editor Supported aix Native

  Path `~/.gemini/settings.json`  | **MCP servers**- Project

  Editor Supported aix Native

  Path `.cursor/mcp.json`

- User

  Editor Supported aix Native

  Path `~/.cursor/mcp.json`                                                                                                                                                     |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.gemini/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.gemini/skills/{name}/`     | **Skills**- Project

  Editor Supported aix Native

  Path `.cursor/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.cursor/skills/{name}/`                                                                                                                                              |
| Agents                        | **Subagents**- Project

  Editor Supported aix Native

  Path `.gemini/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.gemini/agents/*.md`        | **Agents**- Project

  Editor Supported aix Native

  Path `.cursor/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.cursor/agents/*.md`                                                                                                                                                    |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.gemini/settings.json`

- User

  Editor Supported aix Native

  Path `~/.gemini/settings.json`        | **Hooks**- Project

  Editor Supported aix Native

  Path `.cursor/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.cursor/hooks.json`                                                                                                                                                       |

## Recommended follow-up links

* [Gemini support details](/editors/gemini/)
* [Cursor support details](/editors/cursor/)
* [All guides that start from Gemini](/editors/migrations/#gemini)
* [Cursor to Gemini](/editors/migrations/how-to-migrate-from-cursor-to-gemini/)

---

# How to migrate from Gemini to OpenCode

> Compare Gemini to OpenCode, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Gemini to OpenCode, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync gemini --to opencode` copies the supported config from Gemini into OpenCode. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Gemini                                                                                                                                                            | OpenCode                                                                                                                                                                                                                                                                                                                                                             |
| ----------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **GEMINI.md**- Project

  Editor Supported aix Native

  Path `GEMINI.md`

- User

  Editor Supported aix Native

  Path `~/.gemini/GEMINI.md`                    | **AGENTS.md**- Project

  Editor Supported aix Native

  Path `AGENTS.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/AGENTS.md`                                                                                                                                                                                                              |
| [Prompts](/concepts/prompts/) | **Commands**- Project

  Editor Supported aix Native

  Path `.gemini/commands/*.toml`

- User

  Editor Supported aix Native

  Path `~/.gemini/commands/*.toml` | **Commands**- Project

  Editor Supported aix Native

  Path `.opencode/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/commands/*.md`                                                                                                                                                                                             |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor Supported aix Native

  Path `.gemini/settings.json`

- User

  Editor Supported aix Native

  Path `~/.gemini/settings.json`  | **MCP servers**- Project

  Editor Supported aix Native

  Path `opencode.json`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/opencode.json`                                                                                                                                                                                                    |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.gemini/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.gemini/skills/{name}/`     | **Skills**- Project

  Editor Supported aix Native

  Path `.opencode/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/skills/{name}/`                                                                                                                                                                                             |
| Agents                        | **Subagents**- Project

  Editor Supported aix Native

  Path `.gemini/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.gemini/agents/*.md`        | **Agents**- Project

  Editor Supported aix Native

  Path `.opencode/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/agents/*.md`                                                                                                                                                                                                   |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.gemini/settings.json`

- User

  Editor Supported aix Native

  Path `~/.gemini/settings.json`        | **Hooks**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** OpenCode does not support lifecycle hooks in aix.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** OpenCode does not support lifecycle hooks in aix. |

## Recommended follow-up links

* [Gemini support details](/editors/gemini/)
* [OpenCode support details](/editors/opencode/)
* [All guides that start from Gemini](/editors/migrations/#gemini)
* [OpenCode to Gemini](/editors/migrations/how-to-migrate-from-opencode-to-gemini/)

---

# How to migrate from Gemini to Windsurf

> Compare Gemini to Windsurf, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Gemini to Windsurf, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync gemini --to windsurf` copies the supported config from Gemini into Windsurf. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Gemini                                                                                                                                                            | Windsurf                                                                                                                                                                                                                                                                                                                                                                                |
| ----------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **GEMINI.md**- Project

  Editor Supported aix Native

  Path `GEMINI.md`

- User

  Editor Supported aix Native

  Path `~/.gemini/GEMINI.md`                    | **Rules**- Project

  Editor Supported aix Native

  Path `.windsurf/rules/*.md`

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/memories/global_rules.md`                                                                                                                                                                                                          |
| [Prompts](/concepts/prompts/) | **Commands**- Project

  Editor Supported aix Native

  Path `.gemini/commands/*.toml`

- User

  Editor Supported aix Native

  Path `~/.gemini/commands/*.toml` | **Workflows**- Project

  Editor Supported aix Native

  Path `.windsurf/workflows/*.md`

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/global_workflows/*.md`                                                                                                                                                                                                     |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor Supported aix Native

  Path `.gemini/settings.json`

- User

  Editor Supported aix Native

  Path `~/.gemini/settings.json`  | **MCP servers**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Windsurf does not have a project-scoped MCP config file in aix.

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/mcp_config.json`                                                                                        |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.gemini/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.gemini/skills/{name}/`     | **Skills**- Project

  Editor Supported aix Native

  Path `.windsurf/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.windsurf/skills/{name}/`                                                                                                                                                                                                                       |
| Agents                        | **Subagents**- Project

  Editor Supported aix Native

  Path `.gemini/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.gemini/agents/*.md`        | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Windsurf.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Windsurf. |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.gemini/settings.json`

- User

  Editor Supported aix Native

  Path `~/.gemini/settings.json`        | **Hooks**- Project

  Editor Supported aix Native

  Path `.windsurf/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.windsurf/hooks.json`                                                                                                                                                                                                                                |

## Recommended follow-up links

* [Gemini support details](/editors/gemini/)
* [Windsurf support details](/editors/windsurf/)
* [All guides that start from Gemini](/editors/migrations/#gemini)
* [Windsurf to Gemini](/editors/migrations/how-to-migrate-from-windsurf-to-gemini/)

---

# How to migrate from Gemini to Zed

> Compare Gemini to Zed, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Gemini to Zed, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync gemini --to zed` copies the supported config from Gemini into Zed. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Gemini                                                                                                                                                            | Zed                                                                                                                                                                                                                                                                                                                                                                           |
| ----------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **GEMINI.md**- Project

  Editor Supported aix Native

  Path `GEMINI.md`

- User

  Editor Supported aix Native

  Path `~/.gemini/GEMINI.md`                    | **Rules**- Project

  Editor Supported aix Native

  Path `.rules`

- User

  Editor Supported aix Native

  Path `~/.config/zed/AGENTS.md`                                                                                                                                                                                                                                   |
| [Prompts](/concepts/prompts/) | **Commands**- Project

  Editor Supported aix Native

  Path `.gemini/commands/*.toml`

- User

  Editor Supported aix Native

  Path `~/.gemini/commands/*.toml` | **Agent Skills (converted)**- Project

  Editor Supported aix Adapter

  Path `.agents/skills/`

  **aix:** aix converts prompts to Agent Skills in `.agents/skills/<name>/`.

- User

  Editor Supported aix Adapter

  Path `~/.agents/skills/`

  **aix:** aix converts prompts to Agent Skills in `~/.agents/skills/<name>/`.                                             |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor Supported aix Native

  Path `.gemini/settings.json`

- User

  Editor Supported aix Native

  Path `~/.gemini/settings.json`  | **Context servers**- Project

  Editor Supported aix Native

  Path `.zed/settings.json`

- User

  Editor Supported aix Native

  Path `~/.config/zed/settings.json`                                                                                                                                                                                                         |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.gemini/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.gemini/skills/{name}/`     | **Agent Skills**- Project

  Editor Supported aix Native

  Path `.agents/skills/`

- User

  Editor Supported aix Native

  Path `~/.agents/skills/`                                                                                                                                                                                                                         |
| Agents                        | **Subagents**- Project

  Editor Supported aix Native

  Path `.gemini/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.gemini/agents/*.md`        | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Zed.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Zed. |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.gemini/settings.json`

- User

  Editor Supported aix Native

  Path `~/.gemini/settings.json`        | **Hooks**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Zed does not support lifecycle hooks in aix.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Zed does not support lifecycle hooks in aix.                    |

## Recommended follow-up links

* [Gemini support details](/editors/gemini/)
* [Zed support details](/editors/zed/)
* [All guides that start from Gemini](/editors/migrations/#gemini)
* [Zed to Gemini](/editors/migrations/how-to-migrate-from-zed-to-gemini/)

---

# How to migrate from OpenCode to Claude Code

> Compare OpenCode to Claude Code, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from OpenCode to Claude Code, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync opencode --to claude-code` copies the supported config from OpenCode into Claude Code. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | OpenCode                                                                                                                                                                                                                                                                                                                                                             | Claude Code                                                                                                                                                   |
| ----------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **AGENTS.md**- Project

  Editor Supported aix Native

  Path `AGENTS.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/AGENTS.md`                                                                                                                                                                                                              | **Rules**- Project

  Editor Supported aix Native

  Path `.claude/rules/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/CLAUDE.md`           |
| [Prompts](/concepts/prompts/) | **Commands**- Project

  Editor Supported aix Native

  Path `.opencode/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/commands/*.md`                                                                                                                                                                                             | **Commands**- Project

  Editor Supported aix Native

  Path `.claude/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/commands/*.md` |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor Supported aix Native

  Path `opencode.json`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/opencode.json`                                                                                                                                                                                                    | **MCP servers**- Project

  Editor Supported aix Native

  Path `.mcp.json`

- User

  Editor Supported aix Native

  Path `~/.claude.json`                   |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.opencode/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/skills/{name}/`                                                                                                                                                                                             | **Skills**- Project

  Editor Supported aix Native

  Path `.claude/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.claude/skills/{name}/` |
| Agents                        | **Agents**- Project

  Editor Supported aix Native

  Path `.opencode/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/agents/*.md`                                                                                                                                                                                                   | **Subagents**- Project

  Editor Supported aix Native

  Path `.claude/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/agents/*.md`    |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** OpenCode does not support lifecycle hooks in aix.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** OpenCode does not support lifecycle hooks in aix. | **Hooks**- Project

  Editor Supported aix Native

  Path `.claude/settings.json`

- User

  Editor Supported aix Native

  Path `~/.claude/settings.json`    |

## Recommended follow-up links

* [OpenCode support details](/editors/opencode/)
* [Claude Code support details](/editors/claude-code/)
* [All guides that start from OpenCode](/editors/migrations/#opencode)
* [Claude Code to OpenCode](/editors/migrations/how-to-migrate-from-claude-code-to-opencode/)

---

# How to migrate from OpenCode to Codex

> Compare OpenCode to Codex, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from OpenCode to Codex, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync opencode --to codex` copies the supported config from OpenCode into Codex. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | OpenCode                                                                                                                                                                                                                                                                                                                                                             | Codex                                                                                                                                                                                                                                                                                                                                                                             |
| ----------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **AGENTS.md**- Project

  Editor Supported aix Native

  Path `AGENTS.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/AGENTS.md`                                                                                                                                                                                                              | **AGENTS.md**- Project

  Editor Supported aix Native

  Path `AGENTS.md at the project root and selected subdirectories`

- User

  Editor Supported aix Native

  Path `~/.codex/AGENTS.md`                                                                                                                                                                                     |
| [Prompts](/concepts/prompts/) | **Commands**- Project

  Editor Supported aix Native

  Path `.opencode/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/commands/*.md`                                                                                                                                                                                             | **Skills**- Project

  Editor Supported aix Adapter

  Path `.agents/skills/prompt-{name}/`

  **aix:** Prompts are installed as instruction-only Agent Skills.

- User

  Editor Supported aix Adapter

  Path `~/.codex/skills/prompt-{name}/`

  **aix:** User-scoped prompts are also converted to skills.                                                                    |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor Supported aix Native

  Path `opencode.json`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/opencode.json`                                                                                                                                                                                                    | **MCP servers**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix does not yet write Codex project MCP config.

- User

  Editor Supported aix Native

  Path `~/.codex/config.toml`                                                                                                                |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.opencode/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/skills/{name}/`                                                                                                                                                                                             | **Skills**- Project

  Editor Supported aix Native

  Path `.agents/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.codex/skills/{name}/`                                                                                                                                                                                                                      |
| Agents                        | **Agents**- Project

  Editor Supported aix Native

  Path `.opencode/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/agents/*.md`                                                                                                                                                                                                   | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Codex.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Codex. |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** OpenCode does not support lifecycle hooks in aix.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** OpenCode does not support lifecycle hooks in aix. | **Hooks**- Project

  Editor Supported aix Native

  Path `.codex/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.codex/hooks.json`                                                                                                                                                                                                                                |

## Recommended follow-up links

* [OpenCode support details](/editors/opencode/)
* [Codex support details](/editors/codex/)
* [All guides that start from OpenCode](/editors/migrations/#opencode)
* [Codex to OpenCode](/editors/migrations/how-to-migrate-from-codex-to-opencode/)

---

# How to migrate from OpenCode to GitHub Copilot

> Compare OpenCode to GitHub Copilot, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from OpenCode to GitHub Copilot, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync opencode --to copilot` copies the supported config from OpenCode into GitHub Copilot. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | OpenCode                                                                                                                                                                                                                                                                                                                                                             | GitHub Copilot                                                                                                                                                                                                                                                                                                        |
| ----------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **AGENTS.md**- Project

  Editor Supported aix Native

  Path `AGENTS.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/AGENTS.md`                                                                                                                                                                                                              | **Instructions**- Project

  Editor Supported aix Native

  Path `.github/instructions/*.instructions.md`

- User

  Editor Supported aix No support

  Editor target `~/.config/github-copilot/instructions/*.instructions.md`

  **aix:** aix does not yet write user-scope Copilot instructions as separate files. |
| [Prompts](/concepts/prompts/) | **Commands**- Project

  Editor Supported aix Native

  Path `.opencode/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/commands/*.md`                                                                                                                                                                                             | **Prompt files**- Project

  Editor Supported aix Native

  Path `.github/prompts/*.prompt.md`

- User

  Editor Supported aix Adapter

  Path `~/.config/github-copilot/skills/{name}/`

  **aix:** aix converts user-scope prompts into instruction-only Copilot skills.                                            |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor Supported aix Native

  Path `opencode.json`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/opencode.json`                                                                                                                                                                                                    | **MCP servers**- Project

  Editor Supported aix Native

  Path `.mcp.json`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/mcp-config.json`                                                                                                                                                 |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.opencode/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/skills/{name}/`                                                                                                                                                                                             | **Skills**- Project

  Editor Supported aix Native

  Path `.github/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/skills/{name}/`                                                                                                                                          |
| Agents                        | **Agents**- Project

  Editor Supported aix Native

  Path `.opencode/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/agents/*.md`                                                                                                                                                                                                   | **Agents**- Project

  Editor Supported aix Native

  Path `.github/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/agents/*.md`                                                                                                                                                |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** OpenCode does not support lifecycle hooks in aix.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** OpenCode does not support lifecycle hooks in aix. | **Hooks**- Project

  Editor Supported aix Native

  Path `.github/hooks/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/hooks/hooks.json`                                                                                                                                       |

## Recommended follow-up links

* [OpenCode support details](/editors/opencode/)
* [GitHub Copilot support details](/editors/copilot/)
* [All guides that start from OpenCode](/editors/migrations/#opencode)
* [GitHub Copilot to OpenCode](/editors/migrations/how-to-migrate-from-copilot-to-opencode/)

---

# How to migrate from OpenCode to Cursor

> Compare OpenCode to Cursor, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from OpenCode to Cursor, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync opencode --to cursor` copies the supported config from OpenCode into Cursor. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | OpenCode                                                                                                                                                                                                                                                                                                                                                             | Cursor                                                                                                                                                                                                                                                                                                     |
| ----------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **AGENTS.md**- Project

  Editor Supported aix Native

  Path `AGENTS.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/AGENTS.md`                                                                                                                                                                                                              | **Rules**- Project

  Editor Supported aix Native

  Path `.cursor/rules/*.mdc`

- User

  Editor Supported aix No support

  Editor target `Settings UI`

  **Editor:** Cursor stores user rules in the Settings UI rather than a writable file. **aix:** aix does not currently write Cursor user rules. |
| [Prompts](/concepts/prompts/) | **Commands**- Project

  Editor Supported aix Native

  Path `.opencode/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/commands/*.md`                                                                                                                                                                                             | **Commands**- Project

  Editor Supported aix Native

  Path `.cursor/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.cursor/commands/*.md`                                                                                                                                              |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor Supported aix Native

  Path `opencode.json`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/opencode.json`                                                                                                                                                                                                    | **MCP servers**- Project

  Editor Supported aix Native

  Path `.cursor/mcp.json`

- User

  Editor Supported aix Native

  Path `~/.cursor/mcp.json`                                                                                                                                                     |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.opencode/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/skills/{name}/`                                                                                                                                                                                             | **Skills**- Project

  Editor Supported aix Native

  Path `.cursor/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.cursor/skills/{name}/`                                                                                                                                              |
| Agents                        | **Agents**- Project

  Editor Supported aix Native

  Path `.opencode/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/agents/*.md`                                                                                                                                                                                                   | **Agents**- Project

  Editor Supported aix Native

  Path `.cursor/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.cursor/agents/*.md`                                                                                                                                                    |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** OpenCode does not support lifecycle hooks in aix.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** OpenCode does not support lifecycle hooks in aix. | **Hooks**- Project

  Editor Supported aix Native

  Path `.cursor/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.cursor/hooks.json`                                                                                                                                                       |

## Recommended follow-up links

* [OpenCode support details](/editors/opencode/)
* [Cursor support details](/editors/cursor/)
* [All guides that start from OpenCode](/editors/migrations/#opencode)
* [Cursor to OpenCode](/editors/migrations/how-to-migrate-from-cursor-to-opencode/)

---

# How to migrate from OpenCode to Gemini

> Compare OpenCode to Gemini, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from OpenCode to Gemini, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync opencode --to gemini` copies the supported config from OpenCode into Gemini. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | OpenCode                                                                                                                                                                                                                                                                                                                                                             | Gemini                                                                                                                                                            |
| ----------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **AGENTS.md**- Project

  Editor Supported aix Native

  Path `AGENTS.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/AGENTS.md`                                                                                                                                                                                                              | **GEMINI.md**- Project

  Editor Supported aix Native

  Path `GEMINI.md`

- User

  Editor Supported aix Native

  Path `~/.gemini/GEMINI.md`                    |
| [Prompts](/concepts/prompts/) | **Commands**- Project

  Editor Supported aix Native

  Path `.opencode/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/commands/*.md`                                                                                                                                                                                             | **Commands**- Project

  Editor Supported aix Native

  Path `.gemini/commands/*.toml`

- User

  Editor Supported aix Native

  Path `~/.gemini/commands/*.toml` |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor Supported aix Native

  Path `opencode.json`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/opencode.json`                                                                                                                                                                                                    | **MCP servers**- Project

  Editor Supported aix Native

  Path `.gemini/settings.json`

- User

  Editor Supported aix Native

  Path `~/.gemini/settings.json`  |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.opencode/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/skills/{name}/`                                                                                                                                                                                             | **Skills**- Project

  Editor Supported aix Native

  Path `.gemini/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.gemini/skills/{name}/`     |
| Agents                        | **Agents**- Project

  Editor Supported aix Native

  Path `.opencode/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/agents/*.md`                                                                                                                                                                                                   | **Subagents**- Project

  Editor Supported aix Native

  Path `.gemini/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.gemini/agents/*.md`        |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** OpenCode does not support lifecycle hooks in aix.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** OpenCode does not support lifecycle hooks in aix. | **Hooks**- Project

  Editor Supported aix Native

  Path `.gemini/settings.json`

- User

  Editor Supported aix Native

  Path `~/.gemini/settings.json`        |

## Recommended follow-up links

* [OpenCode support details](/editors/opencode/)
* [Gemini support details](/editors/gemini/)
* [All guides that start from OpenCode](/editors/migrations/#opencode)
* [Gemini to OpenCode](/editors/migrations/how-to-migrate-from-gemini-to-opencode/)

---

# How to migrate from OpenCode to Windsurf

> Compare OpenCode to Windsurf, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from OpenCode to Windsurf, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync opencode --to windsurf` copies the supported config from OpenCode into Windsurf. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | OpenCode                                                                                                                                                                                                                                                                                                                                                             | Windsurf                                                                                                                                                                                                                                                                                                                                                                                |
| ----------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **AGENTS.md**- Project

  Editor Supported aix Native

  Path `AGENTS.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/AGENTS.md`                                                                                                                                                                                                              | **Rules**- Project

  Editor Supported aix Native

  Path `.windsurf/rules/*.md`

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/memories/global_rules.md`                                                                                                                                                                                                          |
| [Prompts](/concepts/prompts/) | **Commands**- Project

  Editor Supported aix Native

  Path `.opencode/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/commands/*.md`                                                                                                                                                                                             | **Workflows**- Project

  Editor Supported aix Native

  Path `.windsurf/workflows/*.md`

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/global_workflows/*.md`                                                                                                                                                                                                     |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor Supported aix Native

  Path `opencode.json`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/opencode.json`                                                                                                                                                                                                    | **MCP servers**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Windsurf does not have a project-scoped MCP config file in aix.

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/mcp_config.json`                                                                                        |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.opencode/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/skills/{name}/`                                                                                                                                                                                             | **Skills**- Project

  Editor Supported aix Native

  Path `.windsurf/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.windsurf/skills/{name}/`                                                                                                                                                                                                                       |
| Agents                        | **Agents**- Project

  Editor Supported aix Native

  Path `.opencode/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/agents/*.md`                                                                                                                                                                                                   | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Windsurf.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Windsurf. |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** OpenCode does not support lifecycle hooks in aix.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** OpenCode does not support lifecycle hooks in aix. | **Hooks**- Project

  Editor Supported aix Native

  Path `.windsurf/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.windsurf/hooks.json`                                                                                                                                                                                                                                |

## Recommended follow-up links

* [OpenCode support details](/editors/opencode/)
* [Windsurf support details](/editors/windsurf/)
* [All guides that start from OpenCode](/editors/migrations/#opencode)
* [Windsurf to OpenCode](/editors/migrations/how-to-migrate-from-windsurf-to-opencode/)

---

# How to migrate from OpenCode to Zed

> Compare OpenCode to Zed, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from OpenCode to Zed, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync opencode --to zed` copies the supported config from OpenCode into Zed. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | OpenCode                                                                                                                                                                                                                                                                                                                                                             | Zed                                                                                                                                                                                                                                                                                                                                                                           |
| ----------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **AGENTS.md**- Project

  Editor Supported aix Native

  Path `AGENTS.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/AGENTS.md`                                                                                                                                                                                                              | **Rules**- Project

  Editor Supported aix Native

  Path `.rules`

- User

  Editor Supported aix Native

  Path `~/.config/zed/AGENTS.md`                                                                                                                                                                                                                                   |
| [Prompts](/concepts/prompts/) | **Commands**- Project

  Editor Supported aix Native

  Path `.opencode/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/commands/*.md`                                                                                                                                                                                             | **Agent Skills (converted)**- Project

  Editor Supported aix Adapter

  Path `.agents/skills/`

  **aix:** aix converts prompts to Agent Skills in `.agents/skills/<name>/`.

- User

  Editor Supported aix Adapter

  Path `~/.agents/skills/`

  **aix:** aix converts prompts to Agent Skills in `~/.agents/skills/<name>/`.                                             |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor Supported aix Native

  Path `opencode.json`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/opencode.json`                                                                                                                                                                                                    | **Context servers**- Project

  Editor Supported aix Native

  Path `.zed/settings.json`

- User

  Editor Supported aix Native

  Path `~/.config/zed/settings.json`                                                                                                                                                                                                         |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.opencode/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/skills/{name}/`                                                                                                                                                                                             | **Agent Skills**- Project

  Editor Supported aix Native

  Path `.agents/skills/`

- User

  Editor Supported aix Native

  Path `~/.agents/skills/`                                                                                                                                                                                                                         |
| Agents                        | **Agents**- Project

  Editor Supported aix Native

  Path `.opencode/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/agents/*.md`                                                                                                                                                                                                   | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Zed.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Zed. |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** OpenCode does not support lifecycle hooks in aix.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** OpenCode does not support lifecycle hooks in aix. | **Hooks**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Zed does not support lifecycle hooks in aix.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Zed does not support lifecycle hooks in aix.                    |

## Recommended follow-up links

* [OpenCode support details](/editors/opencode/)
* [Zed support details](/editors/zed/)
* [All guides that start from OpenCode](/editors/migrations/#opencode)
* [Zed to OpenCode](/editors/migrations/how-to-migrate-from-zed-to-opencode/)

---

# How to migrate from Windsurf to Claude Code

> Compare Windsurf to Claude Code, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Windsurf to Claude Code, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync windsurf --to claude-code` copies the supported config from Windsurf into Claude Code. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Windsurf                                                                                                                                                                                                                                                                                                                                                                                | Claude Code                                                                                                                                                   |
| ----------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **Rules**- Project

  Editor Supported aix Native

  Path `.windsurf/rules/*.md`

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/memories/global_rules.md`                                                                                                                                                                                                          | **Rules**- Project

  Editor Supported aix Native

  Path `.claude/rules/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/CLAUDE.md`           |
| [Prompts](/concepts/prompts/) | **Workflows**- Project

  Editor Supported aix Native

  Path `.windsurf/workflows/*.md`

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/global_workflows/*.md`                                                                                                                                                                                                     | **Commands**- Project

  Editor Supported aix Native

  Path `.claude/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/commands/*.md` |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Windsurf does not have a project-scoped MCP config file in aix.

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/mcp_config.json`                                                                                        | **MCP servers**- Project

  Editor Supported aix Native

  Path `.mcp.json`

- User

  Editor Supported aix Native

  Path `~/.claude.json`                   |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.windsurf/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.windsurf/skills/{name}/`                                                                                                                                                                                                                       | **Skills**- Project

  Editor Supported aix Native

  Path `.claude/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.claude/skills/{name}/` |
| Agents                        | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Windsurf.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Windsurf. | **Subagents**- Project

  Editor Supported aix Native

  Path `.claude/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/agents/*.md`    |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.windsurf/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.windsurf/hooks.json`                                                                                                                                                                                                                                | **Hooks**- Project

  Editor Supported aix Native

  Path `.claude/settings.json`

- User

  Editor Supported aix Native

  Path `~/.claude/settings.json`    |

## Recommended follow-up links

* [Windsurf support details](/editors/windsurf/)
* [Claude Code support details](/editors/claude-code/)
* [All guides that start from Windsurf](/editors/migrations/#windsurf)
* [Claude Code to Windsurf](/editors/migrations/how-to-migrate-from-claude-code-to-windsurf/)

---

# How to migrate from Windsurf to Codex

> Compare Windsurf to Codex, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Windsurf to Codex, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync windsurf --to codex` copies the supported config from Windsurf into Codex. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Windsurf                                                                                                                                                                                                                                                                                                                                                                                | Codex                                                                                                                                                                                                                                                                                                                                                                             |
| ----------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **Rules**- Project

  Editor Supported aix Native

  Path `.windsurf/rules/*.md`

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/memories/global_rules.md`                                                                                                                                                                                                          | **AGENTS.md**- Project

  Editor Supported aix Native

  Path `AGENTS.md at the project root and selected subdirectories`

- User

  Editor Supported aix Native

  Path `~/.codex/AGENTS.md`                                                                                                                                                                                     |
| [Prompts](/concepts/prompts/) | **Workflows**- Project

  Editor Supported aix Native

  Path `.windsurf/workflows/*.md`

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/global_workflows/*.md`                                                                                                                                                                                                     | **Skills**- Project

  Editor Supported aix Adapter

  Path `.agents/skills/prompt-{name}/`

  **aix:** Prompts are installed as instruction-only Agent Skills.

- User

  Editor Supported aix Adapter

  Path `~/.codex/skills/prompt-{name}/`

  **aix:** User-scoped prompts are also converted to skills.                                                                    |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Windsurf does not have a project-scoped MCP config file in aix.

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/mcp_config.json`                                                                                        | **MCP servers**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix does not yet write Codex project MCP config.

- User

  Editor Supported aix Native

  Path `~/.codex/config.toml`                                                                                                                |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.windsurf/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.windsurf/skills/{name}/`                                                                                                                                                                                                                       | **Skills**- Project

  Editor Supported aix Native

  Path `.agents/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.codex/skills/{name}/`                                                                                                                                                                                                                      |
| Agents                        | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Windsurf.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Windsurf. | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Codex.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Codex. |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.windsurf/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.windsurf/hooks.json`                                                                                                                                                                                                                                | **Hooks**- Project

  Editor Supported aix Native

  Path `.codex/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.codex/hooks.json`                                                                                                                                                                                                                                |

## Recommended follow-up links

* [Windsurf support details](/editors/windsurf/)
* [Codex support details](/editors/codex/)
* [All guides that start from Windsurf](/editors/migrations/#windsurf)
* [Codex to Windsurf](/editors/migrations/how-to-migrate-from-codex-to-windsurf/)

---

# How to migrate from Windsurf to GitHub Copilot

> Compare Windsurf to GitHub Copilot, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Windsurf to GitHub Copilot, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync windsurf --to copilot` copies the supported config from Windsurf into GitHub Copilot. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Windsurf                                                                                                                                                                                                                                                                                                                                                                                | GitHub Copilot                                                                                                                                                                                                                                                                                                        |
| ----------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **Rules**- Project

  Editor Supported aix Native

  Path `.windsurf/rules/*.md`

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/memories/global_rules.md`                                                                                                                                                                                                          | **Instructions**- Project

  Editor Supported aix Native

  Path `.github/instructions/*.instructions.md`

- User

  Editor Supported aix No support

  Editor target `~/.config/github-copilot/instructions/*.instructions.md`

  **aix:** aix does not yet write user-scope Copilot instructions as separate files. |
| [Prompts](/concepts/prompts/) | **Workflows**- Project

  Editor Supported aix Native

  Path `.windsurf/workflows/*.md`

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/global_workflows/*.md`                                                                                                                                                                                                     | **Prompt files**- Project

  Editor Supported aix Native

  Path `.github/prompts/*.prompt.md`

- User

  Editor Supported aix Adapter

  Path `~/.config/github-copilot/skills/{name}/`

  **aix:** aix converts user-scope prompts into instruction-only Copilot skills.                                            |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Windsurf does not have a project-scoped MCP config file in aix.

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/mcp_config.json`                                                                                        | **MCP servers**- Project

  Editor Supported aix Native

  Path `.mcp.json`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/mcp-config.json`                                                                                                                                                 |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.windsurf/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.windsurf/skills/{name}/`                                                                                                                                                                                                                       | **Skills**- Project

  Editor Supported aix Native

  Path `.github/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/skills/{name}/`                                                                                                                                          |
| Agents                        | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Windsurf.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Windsurf. | **Agents**- Project

  Editor Supported aix Native

  Path `.github/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/agents/*.md`                                                                                                                                                |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.windsurf/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.windsurf/hooks.json`                                                                                                                                                                                                                                | **Hooks**- Project

  Editor Supported aix Native

  Path `.github/hooks/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/hooks/hooks.json`                                                                                                                                       |

## Recommended follow-up links

* [Windsurf support details](/editors/windsurf/)
* [GitHub Copilot support details](/editors/copilot/)
* [All guides that start from Windsurf](/editors/migrations/#windsurf)
* [GitHub Copilot to Windsurf](/editors/migrations/how-to-migrate-from-copilot-to-windsurf/)

---

# How to migrate from Windsurf to Cursor

> Compare Windsurf to Cursor, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Windsurf to Cursor, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync windsurf --to cursor` copies the supported config from Windsurf into Cursor. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Windsurf                                                                                                                                                                                                                                                                                                                                                                                | Cursor                                                                                                                                                                                                                                                                                                     |
| ----------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **Rules**- Project

  Editor Supported aix Native

  Path `.windsurf/rules/*.md`

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/memories/global_rules.md`                                                                                                                                                                                                          | **Rules**- Project

  Editor Supported aix Native

  Path `.cursor/rules/*.mdc`

- User

  Editor Supported aix No support

  Editor target `Settings UI`

  **Editor:** Cursor stores user rules in the Settings UI rather than a writable file. **aix:** aix does not currently write Cursor user rules. |
| [Prompts](/concepts/prompts/) | **Workflows**- Project

  Editor Supported aix Native

  Path `.windsurf/workflows/*.md`

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/global_workflows/*.md`                                                                                                                                                                                                     | **Commands**- Project

  Editor Supported aix Native

  Path `.cursor/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.cursor/commands/*.md`                                                                                                                                              |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Windsurf does not have a project-scoped MCP config file in aix.

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/mcp_config.json`                                                                                        | **MCP servers**- Project

  Editor Supported aix Native

  Path `.cursor/mcp.json`

- User

  Editor Supported aix Native

  Path `~/.cursor/mcp.json`                                                                                                                                                     |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.windsurf/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.windsurf/skills/{name}/`                                                                                                                                                                                                                       | **Skills**- Project

  Editor Supported aix Native

  Path `.cursor/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.cursor/skills/{name}/`                                                                                                                                              |
| Agents                        | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Windsurf.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Windsurf. | **Agents**- Project

  Editor Supported aix Native

  Path `.cursor/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.cursor/agents/*.md`                                                                                                                                                    |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.windsurf/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.windsurf/hooks.json`                                                                                                                                                                                                                                | **Hooks**- Project

  Editor Supported aix Native

  Path `.cursor/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.cursor/hooks.json`                                                                                                                                                       |

## Recommended follow-up links

* [Windsurf support details](/editors/windsurf/)
* [Cursor support details](/editors/cursor/)
* [All guides that start from Windsurf](/editors/migrations/#windsurf)
* [Cursor to Windsurf](/editors/migrations/how-to-migrate-from-cursor-to-windsurf/)

---

# How to migrate from Windsurf to Gemini

> Compare Windsurf to Gemini, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Windsurf to Gemini, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync windsurf --to gemini` copies the supported config from Windsurf into Gemini. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Windsurf                                                                                                                                                                                                                                                                                                                                                                                | Gemini                                                                                                                                                            |
| ----------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **Rules**- Project

  Editor Supported aix Native

  Path `.windsurf/rules/*.md`

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/memories/global_rules.md`                                                                                                                                                                                                          | **GEMINI.md**- Project

  Editor Supported aix Native

  Path `GEMINI.md`

- User

  Editor Supported aix Native

  Path `~/.gemini/GEMINI.md`                    |
| [Prompts](/concepts/prompts/) | **Workflows**- Project

  Editor Supported aix Native

  Path `.windsurf/workflows/*.md`

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/global_workflows/*.md`                                                                                                                                                                                                     | **Commands**- Project

  Editor Supported aix Native

  Path `.gemini/commands/*.toml`

- User

  Editor Supported aix Native

  Path `~/.gemini/commands/*.toml` |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Windsurf does not have a project-scoped MCP config file in aix.

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/mcp_config.json`                                                                                        | **MCP servers**- Project

  Editor Supported aix Native

  Path `.gemini/settings.json`

- User

  Editor Supported aix Native

  Path `~/.gemini/settings.json`  |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.windsurf/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.windsurf/skills/{name}/`                                                                                                                                                                                                                       | **Skills**- Project

  Editor Supported aix Native

  Path `.gemini/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.gemini/skills/{name}/`     |
| Agents                        | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Windsurf.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Windsurf. | **Subagents**- Project

  Editor Supported aix Native

  Path `.gemini/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.gemini/agents/*.md`        |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.windsurf/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.windsurf/hooks.json`                                                                                                                                                                                                                                | **Hooks**- Project

  Editor Supported aix Native

  Path `.gemini/settings.json`

- User

  Editor Supported aix Native

  Path `~/.gemini/settings.json`        |

## Recommended follow-up links

* [Windsurf support details](/editors/windsurf/)
* [Gemini support details](/editors/gemini/)
* [All guides that start from Windsurf](/editors/migrations/#windsurf)
* [Gemini to Windsurf](/editors/migrations/how-to-migrate-from-gemini-to-windsurf/)

---

# How to migrate from Windsurf to OpenCode

> Compare Windsurf to OpenCode, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Windsurf to OpenCode, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync windsurf --to opencode` copies the supported config from Windsurf into OpenCode. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Windsurf                                                                                                                                                                                                                                                                                                                                                                                | OpenCode                                                                                                                                                                                                                                                                                                                                                             |
| ----------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **Rules**- Project

  Editor Supported aix Native

  Path `.windsurf/rules/*.md`

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/memories/global_rules.md`                                                                                                                                                                                                          | **AGENTS.md**- Project

  Editor Supported aix Native

  Path `AGENTS.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/AGENTS.md`                                                                                                                                                                                                              |
| [Prompts](/concepts/prompts/) | **Workflows**- Project

  Editor Supported aix Native

  Path `.windsurf/workflows/*.md`

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/global_workflows/*.md`                                                                                                                                                                                                     | **Commands**- Project

  Editor Supported aix Native

  Path `.opencode/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/commands/*.md`                                                                                                                                                                                             |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Windsurf does not have a project-scoped MCP config file in aix.

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/mcp_config.json`                                                                                        | **MCP servers**- Project

  Editor Supported aix Native

  Path `opencode.json`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/opencode.json`                                                                                                                                                                                                    |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.windsurf/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.windsurf/skills/{name}/`                                                                                                                                                                                                                       | **Skills**- Project

  Editor Supported aix Native

  Path `.opencode/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/skills/{name}/`                                                                                                                                                                                             |
| Agents                        | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Windsurf.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Windsurf. | **Agents**- Project

  Editor Supported aix Native

  Path `.opencode/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/agents/*.md`                                                                                                                                                                                                   |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.windsurf/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.windsurf/hooks.json`                                                                                                                                                                                                                                | **Hooks**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** OpenCode does not support lifecycle hooks in aix.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** OpenCode does not support lifecycle hooks in aix. |

## Recommended follow-up links

* [Windsurf support details](/editors/windsurf/)
* [OpenCode support details](/editors/opencode/)
* [All guides that start from Windsurf](/editors/migrations/#windsurf)
* [OpenCode to Windsurf](/editors/migrations/how-to-migrate-from-opencode-to-windsurf/)

---

# How to migrate from Windsurf to Zed

> Compare Windsurf to Zed, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Windsurf to Zed, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync windsurf --to zed` copies the supported config from Windsurf into Zed. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Windsurf                                                                                                                                                                                                                                                                                                                                                                                | Zed                                                                                                                                                                                                                                                                                                                                                                           |
| ----------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **Rules**- Project

  Editor Supported aix Native

  Path `.windsurf/rules/*.md`

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/memories/global_rules.md`                                                                                                                                                                                                          | **Rules**- Project

  Editor Supported aix Native

  Path `.rules`

- User

  Editor Supported aix Native

  Path `~/.config/zed/AGENTS.md`                                                                                                                                                                                                                                   |
| [Prompts](/concepts/prompts/) | **Workflows**- Project

  Editor Supported aix Native

  Path `.windsurf/workflows/*.md`

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/global_workflows/*.md`                                                                                                                                                                                                     | **Agent Skills (converted)**- Project

  Editor Supported aix Adapter

  Path `.agents/skills/`

  **aix:** aix converts prompts to Agent Skills in `.agents/skills/<name>/`.

- User

  Editor Supported aix Adapter

  Path `~/.agents/skills/`

  **aix:** aix converts prompts to Agent Skills in `~/.agents/skills/<name>/`.                                             |
| [MCP](/concepts/mcp-servers/) | **MCP servers**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Windsurf does not have a project-scoped MCP config file in aix.

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/mcp_config.json`                                                                                        | **Context servers**- Project

  Editor Supported aix Native

  Path `.zed/settings.json`

- User

  Editor Supported aix Native

  Path `~/.config/zed/settings.json`                                                                                                                                                                                                         |
| [Skills](/concepts/skills/)   | **Skills**- Project

  Editor Supported aix Native

  Path `.windsurf/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.windsurf/skills/{name}/`                                                                                                                                                                                                                       | **Agent Skills**- Project

  Editor Supported aix Native

  Path `.agents/skills/`

- User

  Editor Supported aix Native

  Path `~/.agents/skills/`                                                                                                                                                                                                                         |
| Agents                        | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Windsurf.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Windsurf. | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Zed.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Zed. |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor Supported aix Native

  Path `.windsurf/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.windsurf/hooks.json`                                                                                                                                                                                                                                | **Hooks**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Zed does not support lifecycle hooks in aix.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Zed does not support lifecycle hooks in aix.                    |

## Recommended follow-up links

* [Windsurf support details](/editors/windsurf/)
* [Zed support details](/editors/zed/)
* [All guides that start from Windsurf](/editors/migrations/#windsurf)
* [Zed to Windsurf](/editors/migrations/how-to-migrate-from-zed-to-windsurf/)

---

# How to migrate from Zed to Claude Code

> Compare Zed to Claude Code, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Zed to Claude Code, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync zed --to claude-code` copies the supported config from Zed into Claude Code. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Zed                                                                                                                                                                                                                                                                                                                                                                           | Claude Code                                                                                                                                                   |
| ----------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **Rules**- Project

  Editor Supported aix Native

  Path `.rules`

- User

  Editor Supported aix Native

  Path `~/.config/zed/AGENTS.md`                                                                                                                                                                                                                                   | **Rules**- Project

  Editor Supported aix Native

  Path `.claude/rules/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/CLAUDE.md`           |
| [Prompts](/concepts/prompts/) | **Agent Skills (converted)**- Project

  Editor Supported aix Adapter

  Path `.agents/skills/`

  **aix:** aix converts prompts to Agent Skills in `.agents/skills/<name>/`.

- User

  Editor Supported aix Adapter

  Path `~/.agents/skills/`

  **aix:** aix converts prompts to Agent Skills in `~/.agents/skills/<name>/`.                                             | **Commands**- Project

  Editor Supported aix Native

  Path `.claude/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/commands/*.md` |
| [MCP](/concepts/mcp-servers/) | **Context servers**- Project

  Editor Supported aix Native

  Path `.zed/settings.json`

- User

  Editor Supported aix Native

  Path `~/.config/zed/settings.json`                                                                                                                                                                                                         | **MCP servers**- Project

  Editor Supported aix Native

  Path `.mcp.json`

- User

  Editor Supported aix Native

  Path `~/.claude.json`                   |
| [Skills](/concepts/skills/)   | **Agent Skills**- Project

  Editor Supported aix Native

  Path `.agents/skills/`

- User

  Editor Supported aix Native

  Path `~/.agents/skills/`                                                                                                                                                                                                                         | **Skills**- Project

  Editor Supported aix Native

  Path `.claude/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.claude/skills/{name}/` |
| Agents                        | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Zed.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Zed. | **Subagents**- Project

  Editor Supported aix Native

  Path `.claude/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.claude/agents/*.md`    |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Zed does not support lifecycle hooks in aix.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Zed does not support lifecycle hooks in aix.                    | **Hooks**- Project

  Editor Supported aix Native

  Path `.claude/settings.json`

- User

  Editor Supported aix Native

  Path `~/.claude/settings.json`    |

## Recommended follow-up links

* [Zed support details](/editors/zed/)
* [Claude Code support details](/editors/claude-code/)
* [All guides that start from Zed](/editors/migrations/#zed)
* [Claude Code to Zed](/editors/migrations/how-to-migrate-from-claude-code-to-zed/)

---

# How to migrate from Zed to Codex

> Compare Zed to Codex, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Zed to Codex, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync zed --to codex` copies the supported config from Zed into Codex. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Zed                                                                                                                                                                                                                                                                                                                                                                           | Codex                                                                                                                                                                                                                                                                                                                                                                             |
| ----------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **Rules**- Project

  Editor Supported aix Native

  Path `.rules`

- User

  Editor Supported aix Native

  Path `~/.config/zed/AGENTS.md`                                                                                                                                                                                                                                   | **AGENTS.md**- Project

  Editor Supported aix Native

  Path `AGENTS.md at the project root and selected subdirectories`

- User

  Editor Supported aix Native

  Path `~/.codex/AGENTS.md`                                                                                                                                                                                     |
| [Prompts](/concepts/prompts/) | **Agent Skills (converted)**- Project

  Editor Supported aix Adapter

  Path `.agents/skills/`

  **aix:** aix converts prompts to Agent Skills in `.agents/skills/<name>/`.

- User

  Editor Supported aix Adapter

  Path `~/.agents/skills/`

  **aix:** aix converts prompts to Agent Skills in `~/.agents/skills/<name>/`.                                             | **Skills**- Project

  Editor Supported aix Adapter

  Path `.agents/skills/prompt-{name}/`

  **aix:** Prompts are installed as instruction-only Agent Skills.

- User

  Editor Supported aix Adapter

  Path `~/.codex/skills/prompt-{name}/`

  **aix:** User-scoped prompts are also converted to skills.                                                                    |
| [MCP](/concepts/mcp-servers/) | **Context servers**- Project

  Editor Supported aix Native

  Path `.zed/settings.json`

- User

  Editor Supported aix Native

  Path `~/.config/zed/settings.json`                                                                                                                                                                                                         | **MCP servers**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix does not yet write Codex project MCP config.

- User

  Editor Supported aix Native

  Path `~/.codex/config.toml`                                                                                                                |
| [Skills](/concepts/skills/)   | **Agent Skills**- Project

  Editor Supported aix Native

  Path `.agents/skills/`

- User

  Editor Supported aix Native

  Path `~/.agents/skills/`                                                                                                                                                                                                                         | **Skills**- Project

  Editor Supported aix Native

  Path `.agents/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.codex/skills/{name}/`                                                                                                                                                                                                                      |
| Agents                        | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Zed.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Zed. | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Codex.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Codex. |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Zed does not support lifecycle hooks in aix.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Zed does not support lifecycle hooks in aix.                    | **Hooks**- Project

  Editor Supported aix Native

  Path `.codex/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.codex/hooks.json`                                                                                                                                                                                                                                |

## Recommended follow-up links

* [Zed support details](/editors/zed/)
* [Codex support details](/editors/codex/)
* [All guides that start from Zed](/editors/migrations/#zed)
* [Codex to Zed](/editors/migrations/how-to-migrate-from-codex-to-zed/)

---

# How to migrate from Zed to GitHub Copilot

> Compare Zed to GitHub Copilot, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Zed to GitHub Copilot, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync zed --to copilot` copies the supported config from Zed into GitHub Copilot. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Zed                                                                                                                                                                                                                                                                                                                                                                           | GitHub Copilot                                                                                                                                                                                                                                                                                                        |
| ----------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **Rules**- Project

  Editor Supported aix Native

  Path `.rules`

- User

  Editor Supported aix Native

  Path `~/.config/zed/AGENTS.md`                                                                                                                                                                                                                                   | **Instructions**- Project

  Editor Supported aix Native

  Path `.github/instructions/*.instructions.md`

- User

  Editor Supported aix No support

  Editor target `~/.config/github-copilot/instructions/*.instructions.md`

  **aix:** aix does not yet write user-scope Copilot instructions as separate files. |
| [Prompts](/concepts/prompts/) | **Agent Skills (converted)**- Project

  Editor Supported aix Adapter

  Path `.agents/skills/`

  **aix:** aix converts prompts to Agent Skills in `.agents/skills/<name>/`.

- User

  Editor Supported aix Adapter

  Path `~/.agents/skills/`

  **aix:** aix converts prompts to Agent Skills in `~/.agents/skills/<name>/`.                                             | **Prompt files**- Project

  Editor Supported aix Native

  Path `.github/prompts/*.prompt.md`

- User

  Editor Supported aix Adapter

  Path `~/.config/github-copilot/skills/{name}/`

  **aix:** aix converts user-scope prompts into instruction-only Copilot skills.                                            |
| [MCP](/concepts/mcp-servers/) | **Context servers**- Project

  Editor Supported aix Native

  Path `.zed/settings.json`

- User

  Editor Supported aix Native

  Path `~/.config/zed/settings.json`                                                                                                                                                                                                         | **MCP servers**- Project

  Editor Supported aix Native

  Path `.mcp.json`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/mcp-config.json`                                                                                                                                                 |
| [Skills](/concepts/skills/)   | **Agent Skills**- Project

  Editor Supported aix Native

  Path `.agents/skills/`

- User

  Editor Supported aix Native

  Path `~/.agents/skills/`                                                                                                                                                                                                                         | **Skills**- Project

  Editor Supported aix Native

  Path `.github/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/skills/{name}/`                                                                                                                                          |
| Agents                        | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Zed.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Zed. | **Agents**- Project

  Editor Supported aix Native

  Path `.github/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/agents/*.md`                                                                                                                                                |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Zed does not support lifecycle hooks in aix.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Zed does not support lifecycle hooks in aix.                    | **Hooks**- Project

  Editor Supported aix Native

  Path `.github/hooks/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.config/github-copilot/hooks/hooks.json`                                                                                                                                       |

## Recommended follow-up links

* [Zed support details](/editors/zed/)
* [GitHub Copilot support details](/editors/copilot/)
* [All guides that start from Zed](/editors/migrations/#zed)
* [GitHub Copilot to Zed](/editors/migrations/how-to-migrate-from-copilot-to-zed/)

---

# How to migrate from Zed to Cursor

> Compare Zed to Cursor, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Zed to Cursor, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync zed --to cursor` copies the supported config from Zed into Cursor. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Zed                                                                                                                                                                                                                                                                                                                                                                           | Cursor                                                                                                                                                                                                                                                                                                     |
| ----------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **Rules**- Project

  Editor Supported aix Native

  Path `.rules`

- User

  Editor Supported aix Native

  Path `~/.config/zed/AGENTS.md`                                                                                                                                                                                                                                   | **Rules**- Project

  Editor Supported aix Native

  Path `.cursor/rules/*.mdc`

- User

  Editor Supported aix No support

  Editor target `Settings UI`

  **Editor:** Cursor stores user rules in the Settings UI rather than a writable file. **aix:** aix does not currently write Cursor user rules. |
| [Prompts](/concepts/prompts/) | **Agent Skills (converted)**- Project

  Editor Supported aix Adapter

  Path `.agents/skills/`

  **aix:** aix converts prompts to Agent Skills in `.agents/skills/<name>/`.

- User

  Editor Supported aix Adapter

  Path `~/.agents/skills/`

  **aix:** aix converts prompts to Agent Skills in `~/.agents/skills/<name>/`.                                             | **Commands**- Project

  Editor Supported aix Native

  Path `.cursor/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.cursor/commands/*.md`                                                                                                                                              |
| [MCP](/concepts/mcp-servers/) | **Context servers**- Project

  Editor Supported aix Native

  Path `.zed/settings.json`

- User

  Editor Supported aix Native

  Path `~/.config/zed/settings.json`                                                                                                                                                                                                         | **MCP servers**- Project

  Editor Supported aix Native

  Path `.cursor/mcp.json`

- User

  Editor Supported aix Native

  Path `~/.cursor/mcp.json`                                                                                                                                                     |
| [Skills](/concepts/skills/)   | **Agent Skills**- Project

  Editor Supported aix Native

  Path `.agents/skills/`

- User

  Editor Supported aix Native

  Path `~/.agents/skills/`                                                                                                                                                                                                                         | **Skills**- Project

  Editor Supported aix Native

  Path `.cursor/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.cursor/skills/{name}/`                                                                                                                                              |
| Agents                        | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Zed.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Zed. | **Agents**- Project

  Editor Supported aix Native

  Path `.cursor/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.cursor/agents/*.md`                                                                                                                                                    |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Zed does not support lifecycle hooks in aix.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Zed does not support lifecycle hooks in aix.                    | **Hooks**- Project

  Editor Supported aix Native

  Path `.cursor/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.cursor/hooks.json`                                                                                                                                                       |

## Recommended follow-up links

* [Zed support details](/editors/zed/)
* [Cursor support details](/editors/cursor/)
* [All guides that start from Zed](/editors/migrations/#zed)
* [Cursor to Zed](/editors/migrations/how-to-migrate-from-cursor-to-zed/)

---

# How to migrate from Zed to Gemini

> Compare Zed to Gemini, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Zed to Gemini, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync zed --to gemini` copies the supported config from Zed into Gemini. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Zed                                                                                                                                                                                                                                                                                                                                                                           | Gemini                                                                                                                                                            |
| ----------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **Rules**- Project

  Editor Supported aix Native

  Path `.rules`

- User

  Editor Supported aix Native

  Path `~/.config/zed/AGENTS.md`                                                                                                                                                                                                                                   | **GEMINI.md**- Project

  Editor Supported aix Native

  Path `GEMINI.md`

- User

  Editor Supported aix Native

  Path `~/.gemini/GEMINI.md`                    |
| [Prompts](/concepts/prompts/) | **Agent Skills (converted)**- Project

  Editor Supported aix Adapter

  Path `.agents/skills/`

  **aix:** aix converts prompts to Agent Skills in `.agents/skills/<name>/`.

- User

  Editor Supported aix Adapter

  Path `~/.agents/skills/`

  **aix:** aix converts prompts to Agent Skills in `~/.agents/skills/<name>/`.                                             | **Commands**- Project

  Editor Supported aix Native

  Path `.gemini/commands/*.toml`

- User

  Editor Supported aix Native

  Path `~/.gemini/commands/*.toml` |
| [MCP](/concepts/mcp-servers/) | **Context servers**- Project

  Editor Supported aix Native

  Path `.zed/settings.json`

- User

  Editor Supported aix Native

  Path `~/.config/zed/settings.json`                                                                                                                                                                                                         | **MCP servers**- Project

  Editor Supported aix Native

  Path `.gemini/settings.json`

- User

  Editor Supported aix Native

  Path `~/.gemini/settings.json`  |
| [Skills](/concepts/skills/)   | **Agent Skills**- Project

  Editor Supported aix Native

  Path `.agents/skills/`

- User

  Editor Supported aix Native

  Path `~/.agents/skills/`                                                                                                                                                                                                                         | **Skills**- Project

  Editor Supported aix Native

  Path `.gemini/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.gemini/skills/{name}/`     |
| Agents                        | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Zed.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Zed. | **Subagents**- Project

  Editor Supported aix Native

  Path `.gemini/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.gemini/agents/*.md`        |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Zed does not support lifecycle hooks in aix.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Zed does not support lifecycle hooks in aix.                    | **Hooks**- Project

  Editor Supported aix Native

  Path `.gemini/settings.json`

- User

  Editor Supported aix Native

  Path `~/.gemini/settings.json`        |

## Recommended follow-up links

* [Zed support details](/editors/zed/)
* [Gemini support details](/editors/gemini/)
* [All guides that start from Zed](/editors/migrations/#zed)
* [Gemini to Zed](/editors/migrations/how-to-migrate-from-gemini-to-zed/)

---

# How to migrate from Zed to OpenCode

> Compare Zed to OpenCode, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Zed to OpenCode, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync zed --to opencode` copies the supported config from Zed into OpenCode. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Zed                                                                                                                                                                                                                                                                                                                                                                           | OpenCode                                                                                                                                                                                                                                                                                                                                                             |
| ----------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **Rules**- Project

  Editor Supported aix Native

  Path `.rules`

- User

  Editor Supported aix Native

  Path `~/.config/zed/AGENTS.md`                                                                                                                                                                                                                                   | **AGENTS.md**- Project

  Editor Supported aix Native

  Path `AGENTS.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/AGENTS.md`                                                                                                                                                                                                              |
| [Prompts](/concepts/prompts/) | **Agent Skills (converted)**- Project

  Editor Supported aix Adapter

  Path `.agents/skills/`

  **aix:** aix converts prompts to Agent Skills in `.agents/skills/<name>/`.

- User

  Editor Supported aix Adapter

  Path `~/.agents/skills/`

  **aix:** aix converts prompts to Agent Skills in `~/.agents/skills/<name>/`.                                             | **Commands**- Project

  Editor Supported aix Native

  Path `.opencode/commands/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/commands/*.md`                                                                                                                                                                                             |
| [MCP](/concepts/mcp-servers/) | **Context servers**- Project

  Editor Supported aix Native

  Path `.zed/settings.json`

- User

  Editor Supported aix Native

  Path `~/.config/zed/settings.json`                                                                                                                                                                                                         | **MCP servers**- Project

  Editor Supported aix Native

  Path `opencode.json`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/opencode.json`                                                                                                                                                                                                    |
| [Skills](/concepts/skills/)   | **Agent Skills**- Project

  Editor Supported aix Native

  Path `.agents/skills/`

- User

  Editor Supported aix Native

  Path `~/.agents/skills/`                                                                                                                                                                                                                         | **Skills**- Project

  Editor Supported aix Native

  Path `.opencode/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/skills/{name}/`                                                                                                                                                                                             |
| Agents                        | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Zed.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Zed. | **Agents**- Project

  Editor Supported aix Native

  Path `.opencode/agents/*.md`

- User

  Editor Supported aix Native

  Path `~/.config/opencode/agents/*.md`                                                                                                                                                                                                   |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Zed does not support lifecycle hooks in aix.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Zed does not support lifecycle hooks in aix.                    | **Hooks**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** OpenCode does not support lifecycle hooks in aix.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** OpenCode does not support lifecycle hooks in aix. |

## Recommended follow-up links

* [Zed support details](/editors/zed/)
* [OpenCode support details](/editors/opencode/)
* [All guides that start from Zed](/editors/migrations/#zed)
* [OpenCode to Zed](/editors/migrations/how-to-migrate-from-opencode-to-zed/)

---

# How to migrate from Zed to Windsurf

> Compare Zed to Windsurf, including rules, prompts, mcp differences in terminology, support, and scope.

aix is a CLI for defining, installing, and syncing AI editor configuration. If you are moving from Zed to Windsurf, this guide shows what aix can carry over, what the destination editor calls each feature, and where the destination config lands.

When you are ready to run the move, `aix sync zed --to windsurf` copies the supported config from Zed into Windsurf. Use the comparison below first so you know which names, paths, and support differences to expect.

If you want the aix-side definitions first, review [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## How to use this guide

* Read across a row to compare the source and destination terms, support, and targets.
* Each scope line shows both what the editor supports and what aix writes today.
* Open the destination editor page at the end if you need every path, note, and terminology detail.

The biggest changes are in rules, prompts, mcp.

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

## Feature comparison

| Feature                       | Zed                                                                                                                                                                                                                                                                                                                                                                           | Windsurf                                                                                                                                                                                                                                                                                                                                                                                |
| ----------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Rules](/concepts/rules/)     | **Rules**- Project

  Editor Supported aix Native

  Path `.rules`

- User

  Editor Supported aix Native

  Path `~/.config/zed/AGENTS.md`                                                                                                                                                                                                                                   | **Rules**- Project

  Editor Supported aix Native

  Path `.windsurf/rules/*.md`

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/memories/global_rules.md`                                                                                                                                                                                                          |
| [Prompts](/concepts/prompts/) | **Agent Skills (converted)**- Project

  Editor Supported aix Adapter

  Path `.agents/skills/`

  **aix:** aix converts prompts to Agent Skills in `.agents/skills/<name>/`.

- User

  Editor Supported aix Adapter

  Path `~/.agents/skills/`

  **aix:** aix converts prompts to Agent Skills in `~/.agents/skills/<name>/`.                                             | **Workflows**- Project

  Editor Supported aix Native

  Path `.windsurf/workflows/*.md`

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/global_workflows/*.md`                                                                                                                                                                                                     |
| [MCP](/concepts/mcp-servers/) | **Context servers**- Project

  Editor Supported aix Native

  Path `.zed/settings.json`

- User

  Editor Supported aix Native

  Path `~/.config/zed/settings.json`                                                                                                                                                                                                         | **MCP servers**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Windsurf does not have a project-scoped MCP config file in aix.

- User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/mcp_config.json`                                                                                        |
| [Skills](/concepts/skills/)   | **Agent Skills**- Project

  Editor Supported aix Native

  Path `.agents/skills/`

- User

  Editor Supported aix Native

  Path `~/.agents/skills/`                                                                                                                                                                                                                         | **Skills**- Project

  Editor Supported aix Native

  Path `.windsurf/skills/{name}/`

- User

  Editor Supported aix Native

  Path `~/.windsurf/skills/{name}/`                                                                                                                                                                                                                       |
| Agents                        | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Zed.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Zed. | **Agents**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Windsurf.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Windsurf. |
| [Hooks](/concepts/hooks/)     | **Hooks**- Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Zed does not support lifecycle hooks in aix.

- User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Zed does not support lifecycle hooks in aix.                    | **Hooks**- Project

  Editor Supported aix Native

  Path `.windsurf/hooks.json`

- User

  Editor Supported aix Native

  Path `~/.windsurf/hooks.json`                                                                                                                                                                                                                                |

## Recommended follow-up links

* [Zed support details](/editors/zed/)
* [Windsurf support details](/editors/windsurf/)
* [All guides that start from Zed](/editors/migrations/#zed)
* [Windsurf to Zed](/editors/migrations/how-to-migrate-from-windsurf-to-zed/)

---

# OpenCode support details

> How aix maps rules, prompts, MCP, skills, hooks, and compatibility surfaces for OpenCode.

Native AGENTS.md rules, markdown commands, MCP, and skills with user-scope support.

OpenCode stays close to Claude-style commands and skills while keeping AGENTS.md as the rule surface.

Start on [the full support matrix](/editors/supported-editors/) when you need to compare every editor at once. Use this page when you want the exact terms, support details, and project/user targets for OpenCode.

Related aix concepts: [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## Editor-specific notes

* OpenCode uses `opencode.json` with a top-level `mcp` object instead of `mcpServers`.
* Rules are written with section-managed markdown so user-owned AGENTS.md content is preserved.

## Feature details

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

### Rules [Learn the concept](/concepts/rules/)

Section-managed markdown in AGENTS.md.

OpenCode calls this **AGENTS.md**

aix support Native

* Project

  Editor Supported aix Native

  Path `AGENTS.md`

* User

  Editor Supported aix Native

  Path `~/.config/opencode/AGENTS.md`

### Prompts [Learn the concept](/concepts/prompts/)

Markdown command files with optional YAML frontmatter.

OpenCode calls this **Commands**

aix support Native

* Project

  Editor Supported aix Native

  Path `.opencode/commands/*.md`

* User

  Editor Supported aix Native

  Path `~/.config/opencode/commands/*.md`

**Supported metadata:** `description` , `argument-hint`

### MCP [Learn the concept](/concepts/mcp-servers/)

JSON config with a top-level `mcp` object.

OpenCode calls this **MCP servers**

aix support Native

* Project

  Editor Supported aix Native

  Path `opencode.json`

* User

  Editor Supported aix Native

  Path `~/.config/opencode/opencode.json`

### Skills [Learn the concept](/concepts/skills/)

Symlinked native skill directories backed by `.aix/skills/`.

OpenCode calls this **Skills**

aix support Native

* Project

  Editor Supported aix Native

  Path `.opencode/skills/{name}/`

* User

  Editor Supported aix Native

  Path `~/.config/opencode/skills/{name}/`

- OpenCode also discovers `.agents/skills/` as a compatibility surface.

### Agents

Markdown agent files with YAML frontmatter.

OpenCode calls this **Agents**

aix support Native

* Project

  Editor Supported aix Native

  Path `.opencode/agents/*.md`

* User

  Editor Supported aix Native

  Path `~/.config/opencode/agents/*.md`

**Supported metadata:** `description` , `mode` , `model` , `tools` , `permissions` , `editor.opencode`

### Hooks [Learn the concept](/concepts/hooks/)

Hooks are not supported.

OpenCode calls this **Hooks**

aix support No support

* Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** OpenCode does not support lifecycle hooks in aix.

* User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** OpenCode does not support lifecycle hooks in aix.

### AGENTS.md

OpenCode natively uses AGENTS.md for project and user instructions.

OpenCode calls this **AGENTS.md**

aix support Native

* Project

  Editor Supported aix Native

  Path `AGENTS.md`

* User

  Editor Supported aix Native

  Path `~/.config/opencode/AGENTS.md`

### .agents/skills

Compatibility with the shared Agent Skills folder convention.

OpenCode calls this **.agents/skills**

aix support Native

* Project

  Editor Supported aix Native

  Path `.agents/skills/{name}/`

* User

  Editor Supported aix Native

  Path `Compatible home-scoped skill discovery`

## Related guides

* [OpenCode to Cursor](/editors/migrations/how-to-migrate-from-opencode-to-cursor/)
* [Cursor to OpenCode](/editors/migrations/how-to-migrate-from-cursor-to-opencode/)
* [All migration guides that start from OpenCode](/editors/migrations/#opencode)

---

# Supported Editors

> Feature support matrix for all editors detected by aix, with links to per-editor support details.

aix currently supports 8 editors: Cursor, GitHub Copilot, Claude Code, Windsurf, Zed, Codex, Gemini, and OpenCode.

Use the matrix for the fast comparison, then open an editor name for install paths, scope behavior, terminology, and editor-specific notes.

| Editor                               | [Rules](/concepts/rules/) | [Prompts](/concepts/prompts/) | [MCP](/concepts/mcp-servers/) | [Skills](/concepts/skills/) | Agents     | [Hooks](/concepts/hooks/) | AGENTS.md  | .agents/skills |
| ------------------------------------ | ------------------------- | ----------------------------- | ----------------------------- | --------------------------- | ---------- | ------------------------- | ---------- | -------------- |
| [Cursor](/editors/cursor/)           | Native                    | Native                        | Native                        | Native                      | Native     | Native                    | Native     | Native         |
| [GitHub Copilot](/editors/copilot/)  | Native                    | Native                        | Native                        | Native                      | Native     | Native                    | Native     | Native         |
| [Claude Code](/editors/claude-code/) | Native                    | Native                        | Native                        | Native                      | Native     | Native                    | No support | No support     |
| [Windsurf](/editors/windsurf/)       | Native                    | Native                        | Native                        | Native                      | No support | Native                    | Native     | Native         |
| [Zed](/editors/zed/)                 | Native                    | Adapter                       | Native                        | Native                      | No support | No support                | Native     | Native         |
| [Codex](/editors/codex/)             | Native                    | Adapter                       | Native                        | Native                      | No support | Native                    | Native     | Native         |
| [Gemini](/editors/gemini/)           | Native                    | Native                        | Native                        | Native                      | Native     | Native                    | Native     | Native         |
| [OpenCode](/editors/opencode/)       | Native                    | Native                        | Native                        | Native                      | Native     | No support                | Native     | Native         |

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

Need the aix-side definitions first? Review [rules](/concepts/rules/), [prompts](/concepts/prompts/), [MCP servers](/concepts/mcp-servers/), [skills](/concepts/skills/), and [hooks](/concepts/hooks/).

## Sync behavior

`aix sync` reads supported config from one editor and writes the supported equivalent to another. It reports anything the destination editor or requested scope cannot represent.

* A destination may support a feature in general, but not at the requested scope.
* Global-only features are reported as skipped project writes instead of hard failures.
* Codex prompts become skills, and Zed skills become pointer rules.

---

# Windsurf support details

> How aix maps rules, prompts, MCP, skills, hooks, and compatibility surfaces for Windsurf.

Native rules, workflows, skills, and hooks, but MCP remains global-only.

Windsurf is strongest when project rules matter more than project-scoped MCP.

Start on [the full support matrix](/editors/supported-editors/) when you need to compare every editor at once. Use this page when you want the exact terms, support details, and project/user targets for Windsurf.

Related aix concepts: [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## Editor-specific notes

* Windsurf MCP installs are tracked as global state because the editor only supports global MCP today.
* Its prompt surface is called workflows, not commands.

## Feature details

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

### Rules [Learn the concept](/concepts/rules/)

Markdown rule files with Windsurf trigger frontmatter.

Windsurf calls this **Rules**

aix support Native

* Project

  Editor Supported aix Native

  Path `.windsurf/rules/*.md`

* User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/memories/global_rules.md`

**Supported metadata:** `always_on` , `model_decision` , `glob` , `manual`

### Prompts [Learn the concept](/concepts/prompts/)

Markdown workflow files with YAML frontmatter.

Windsurf calls this **Workflows**

aix support Native

* Project

  Editor Supported aix Native

  Path `.windsurf/workflows/*.md`

* User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/global_workflows/*.md`

**Supported metadata:** `description`

### MCP [Learn the concept](/concepts/mcp-servers/)

Global-only JSON MCP configuration.

Windsurf calls this **MCP servers**

aix support Native

* Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Windsurf does not have a project-scoped MCP config file in aix.

* User

  Editor Supported aix Native

  Path `~/.codeium/windsurf/mcp_config.json`

- Project-scoped syncs report MCP as a skipped global-only write.

### Skills [Learn the concept](/concepts/skills/)

Symlinked native skill directories backed by `.aix/skills/`.

Windsurf calls this **Skills**

aix support Native

* Project

  Editor Supported aix Native

  Path `.windsurf/skills/{name}/`

* User

  Editor Supported aix Native

  Path `~/.windsurf/skills/{name}/`

- Windsurf also discovers `.agents/skills/` for compatibility.

### Agents

Windsurf does not document custom agent files that aix can write safely.

Windsurf calls this **Agents**

aix support No support

* Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Windsurf.

* User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Windsurf.

### Hooks [Learn the concept](/concepts/hooks/)

JSON hook configuration using snake\_case Windsurf event names with cross-platform `command` / `powershell` fields.

Windsurf calls this **Hooks**

aix support Native

* Project

  Editor Supported aix Native

  Path `.windsurf/hooks.json`

* User

  Editor Supported aix Native

  Path `~/.windsurf/hooks.json`

**Supported metadata:** `post_cascade_response` , `post_cascade_response_with_transcript` , `post_mcp_tool_use` , `post_read_code` , `post_run_command` , `post_setup_worktree` , `post_write_code` , `pre_mcp_tool_use` , `pre_read_code` , `pre_run_command` , `pre_user_prompt` , `pre_write_code`

* Each hook entry can carry `command` (bash) and/or `powershell` for cross-platform routing.
* Pre-hooks block actions with exit code 2; post hooks cannot block.

### AGENTS.md

Compatibility with AGENTS.md and agents.md repository files.

Windsurf calls this **AGENTS.md**

aix support Native

* Project

  Editor Supported aix Native

  Path `AGENTS.md or agents.md in the workspace`

* User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Windsurf documentation focuses on workspace files, not a home-scoped AGENTS.md.

### .agents/skills

Compatibility with the shared Agent Skills folder convention.

Windsurf calls this **.agents/skills**

aix support Native

* Project

  Editor Supported aix Native

  Path `.agents/skills/{name}/`

* User

  Editor Supported aix Native

  Path `~/.agents/skills/{name}/`

## Related guides

* [Windsurf to Cursor](/editors/migrations/how-to-migrate-from-windsurf-to-cursor/)
* [Cursor to Windsurf](/editors/migrations/how-to-migrate-from-cursor-to-windsurf/)
* [All migration guides that start from Windsurf](/editors/migrations/#windsurf)

---

# Zed support details

> How aix maps rules, prompts, MCP, skills, hooks, and compatibility surfaces for Zed.

Native rules and MCP, native Agent Skills, and prompts convert to skills.

Zed is a strong target for rules, MCP, and skills after the v1.4.2 native skills update.

Start on [the full support matrix](/editors/supported-editors/) when you need to compare every editor at once. Use this page when you want the exact terms, support details, and project/user targets for Zed.

Related aix concepts: [rules](/concepts/rules/) , [prompts](/concepts/prompts/) , [mcp](/concepts/mcp-servers/) , [skills](/concepts/skills/) , [hooks](/concepts/hooks/) .

## Editor-specific notes

* Zed reads a single `.rules` file at project scope; user-scope rules go to `~/.config/zed/AGENTS.md`.
* Zed native Agent Skills live at `.agents/skills/<name>/`; aix manages them via `.aix/skills/` symlinks.
* Prompts are converted to Zed skills because Zed has no file-based prompt format.

## Feature details

How to read the statuses

## Support key

### Editor support

* Supported The editor exposes that feature at that scope.
* No support The editor does not expose that feature at that scope.

### aix support

* Native aix writes the editor's own format.
* Adapter aix keeps the feature through an adapter or alternate representation.
* No support aix does not write that feature for the destination today.

Use the Project scope and User scope rows to see where config lands at each level.

### Rules [Learn the concept](/concepts/rules/)

A single concatenated `.rules` file at project scope; `~/.config/zed/AGENTS.md` at user scope.

Zed calls this **Rules**

aix support Native

* Project

  Editor Supported aix Native

  Path `.rules`

* User

  Editor Supported aix Native

  Path `~/.config/zed/AGENTS.md`

- Zed also auto-detects AGENTS.md, CLAUDE.md, and other compatibility files.

### Prompts [Learn the concept](/concepts/prompts/)

Prompts are converted to Zed Agent Skills because Zed has no file-based prompt format.

Zed calls this **Agent Skills (converted)**

aix support Adapter

* Project

  Editor Supported aix Adapter

  Path `.agents/skills/`

  **aix:** aix converts prompts to Agent Skills in `.agents/skills/<name>/`.

* User

  Editor Supported aix Adapter

  Path `~/.agents/skills/`

  **aix:** aix converts prompts to Agent Skills in `~/.agents/skills/<name>/`.

- Zed does support MCP server-side prompts, but not file-based user prompts.

### MCP [Learn the concept](/concepts/mcp-servers/)

JSON `context_servers` configuration.

Zed calls this **Context servers**

aix support Native

* Project

  Editor Supported aix Native

  Path `.zed/settings.json`

* User

  Editor Supported aix Native

  Path `~/.config/zed/settings.json`

### Skills [Learn the concept](/concepts/skills/)

Native Zed Agent Skills. aix copies skills to `.aix/skills/` and symlinks into `.agents/skills/<name>/`.

Zed calls this **Agent Skills**

aix support Native

* Project

  Editor Supported aix Native

  Path `.agents/skills/`

* User

  Editor Supported aix Native

  Path `~/.agents/skills/`

### Agents

Zed does not document custom agent files that aix can write safely.

Zed calls this **Agents**

aix support No support

* Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Zed.

* User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** aix reports configured agents as unsupported for Zed.

### Hooks [Learn the concept](/concepts/hooks/)

Hooks are not supported.

Zed calls this **Hooks**

aix support No support

* Project

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Zed does not support lifecycle hooks in aix.

* User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Zed does not support lifecycle hooks in aix.

### AGENTS.md

Compatibility with AGENTS.md repository instructions.

Zed calls this **AGENTS.md**

aix support Native

* Project

  Editor Supported aix Native

  Path `AGENTS.md`

* User

  Editor No support aix No support

  **Editor:** The editor does not expose this feature at this scope. **aix:** Zed compatibility is documented for workspace files, not a home-scoped AGENTS.md.

### .agents/skills

Zed discovers skills at `.agents/skills/<name>/` (project) and `~/.agents/skills/<name>/` (user).

Zed calls this **.agents/skills**

aix support Native

* Project

  Editor Supported aix Native

  Path `.agents/skills/`

* User

  Editor Supported aix Native

  Path `~/.agents/skills/`

## Related guides

* [Zed to Cursor](/editors/migrations/how-to-migrate-from-zed-to-cursor/)
* [Cursor to Zed](/editors/migrations/how-to-migrate-from-cursor-to-zed/)
* [All migration guides that start from Zed](/editors/migrations/#zed)

---

# Import from an Editor

> Bootstrap ai.json from your existing editor configuration.

If you already have rules, MCP servers, or other AI config in your editor, `aix init --from` can convert it into an `ai.json` for you.

If you do not want an intermediate `ai.json` yet, and just want to move supported config from one editor to another, use `aix sync <from> --to <to>` instead.

## Usage

[Section titled “Usage”](#usage)

```bash
aix init --from <editor>
```

Supported editors:

| Editor         | Flag value    |
| -------------- | ------------- |
| Cursor         | `cursor`      |
| GitHub Copilot | `copilot`     |
| Claude Code    | `claude-code` |
| Windsurf       | `windsurf`    |
| Zed            | `zed`         |
| Codex          | `codex`       |
| Gemini         | `gemini`      |
| OpenCode       | `opencode`    |

## What gets imported

[Section titled “What gets imported”](#what-gets-imported)

aix reads the editor’s existing config files and extracts:

* **Rules** — `.cursorrules`, `.windsurfrules`, `.github/copilot-instructions.md`, etc.
* **MCP servers** — from the editor’s MCP config JSON
* **Prompts** — custom prompt files if the editor stores them
* **Skills** — any SKILL.md references

Imported content is written to `.aix/imported/` and referenced from `ai.json`:

```json
{
   "rules": {
      "imported-cursor": {
         "path": ".aix/imported/rules/cursor.md"
      }
   },
   "mcp": {
      "github": {
         "command": "npx",
         "args": ["-y", "@modelcontextprotocol/server-github"],
         "env": {
            "GITHUB_TOKEN": "${GITHUB_TOKEN}"
         }
      }
   }
}
```

## init —from vs sync

[Section titled “init —from vs sync”](#init-from-vs-sync)

* `aix init --from cursor` reads Cursor and creates `ai.json`.
* `aix sync cursor --to claude-code` reads Cursor and writes Claude Code directly.

Sync reads the supported config from the source editor and writes the supported equivalent to the destination editor. aix does not require a custom converter for every editor pair.

## Overwrite protection

[Section titled “Overwrite protection”](#overwrite-protection)

If `ai.json` already exists, `aix init --from` will refuse to overwrite it. Use `--force` to override:

```bash
aix init --from cursor --force
```

## Next steps

[Section titled “Next steps”](#next-steps)

After importing, review the generated `ai.json` and clean up anything that doesn’t apply across editors. Then run:

```bash
aix install
```

This syncs the config to all your detected editors — including the one you originally imported from.

---

# Installation

> Install the aix CLI and set up your environment.

## Requirements

[Section titled “Requirements”](#requirements)

* **Node.js** ≥ 20.19.0 or ≥ 22.12.0
* **npm** ≥ 10.0.0

## Install

[Section titled “Install”](#install)

```bash
npm install -g @a1st/aix
```

Verify the installation:

```bash
aix --version
```

## Shell autocomplete

[Section titled “Shell autocomplete”](#shell-autocomplete)

aix supports tab completion for commands and flags. Set it up with:

```bash
aix autocomplete
```

Follow the printed instructions to add the completion script to your shell profile (`.bashrc`, `.zshrc`, or Fish config).

## Update

[Section titled “Update”](#update)

aix can self-update:

```bash
aix update
```

## What’s next

[Section titled “What’s next”](#whats-next)

Create your first `ai.json` — follow the [Quick Start](/getting-started/quick-start/) guide.

---

# Quick Start

> Create your first ai.json and install it to your editors in under a minute.

## 1. Initialize ai.json

[Section titled “1. Initialize ai.json”](#1-initialize-aijson)

Run `aix init` in your project root:

```bash
aix init
```

This creates a minimal `ai.json`:

```json
{
   "skills": {},
   "mcp": {},
   "rules": {},
   "prompts": {}
}
```

Already have editor config?

If your editor already has AI rules, prompts, or MCP servers configured, `--from` can import them directly:

```bash
aix init --from cursor
```

This reads your existing editor config and generates a pre-populated `ai.json`, writing imported files to `.aix/imported/`. See the [full import guide](/getting-started/import-from-editor/) for supported editors and details.

## 2. Add some configuration

[Section titled “2. Add some configuration”](#2-add-some-configuration)

Add a rule, a prompt, and an MCP server:

```bash
# Add a rule (inline text)
aix add rule "Always use TypeScript strict mode" --name typescript-strict


# Add a prompt from a file
aix add prompt ./prompts/review.md --name review


# Add an MCP server from the registry
aix add mcp github
```

Your `ai.json` now looks something like:

```json
{
   "skills": {},
   "mcp": {
      "github": {
         "command": "npx",
         "args": ["-y", "@modelcontextprotocol/server-github"],
         "env": {
            "GITHUB_TOKEN": "${GITHUB_TOKEN}"
         }
      }
   },
   "rules": {
      "typescript-strict": {
         "content": "Always use TypeScript strict mode"
      }
   },
   "prompts": {
      "review": "./prompts/review.md"
   }
}
```

## 3. Install to your editors

[Section titled “3. Install to your editors”](#3-install-to-your-editors)

```bash
aix install
```

aix detects which AI editors you have installed and syncs the config to each one. You’ll see output like:

```plaintext
✓ Cursor — 1 rule, 1 prompt, 1 MCP server
✓ GitHub Copilot — 1 rule, 1 prompt, 1 MCP server
✓ Claude Code — 1 rule, 1 prompt, 1 MCP server
```

Run `aix install` again whenever you change `ai.json`.

Preview before applying

Use `--dry-run` to see what aix would write without making any changes:

```bash
aix install --dry-run
```

## What’s next

[Section titled “What’s next”](#whats-next)

* Learn about [skills](/concepts/skills/), [rules](/concepts/rules/), [prompts](/concepts/prompts/), and [MCP servers](/concepts/mcp-servers/)
* See the full [ai.json reference](/configuration/ai-json-reference/)
* Browse the [CLI reference](/cli/overview/)
* Already have editor config? [Import it](/getting-started/import-from-editor/)