You've spent weeks tuning your AI coding agent. Rules for how it handles your React components. Skills for your deployment workflow. Ignore patterns so it stays out of generated code. Slash commands for common operations. It all works beautifully.

Then your team gets Claude Code licenses. Or you want to try Cursor on a side project. Or half your team uses one tool and half uses the other.

Your choices: re-create everything by hand, or lose it.

I built [a16n](https://github.com/Texarkanine/a16n) so neither has to happen.

## What It Does

```bash
npx a16n convert --from cursor --to claude
```

That reads your Cursor rules, skills, commands, and ignore patterns, and writes equivalent Claude Code configuration. The reverse works too:

```bash
npx a16n convert --from claude --to cursor
```

Your carefully-crafted agent setup comes with you. One command, both directions.

## Getting Started

No install required. `npx` handles it:

```bash
# See what you have (without changing anything)
npx a16n discover --from cursor

# Preview the conversion
npx a16n convert --from cursor --to claude --dry-run

# Do it for real
npx a16n convert --from cursor --to claude
```

That's the whole recipe. Three commands: inspect, preview, convert.

If you want it permanently:

```bash
npm install -g a16n
```

## What Converts

a16n understands six kinds of agent customization:

| What | Cursor | Claude Code |
|------|--------|-------------|
| **Global prompts** | `alwaysApply: true` rules | `CLAUDE.md`, `.claude/rules/*.md` |
| **File rules** | `globs: [...]` rules | `.claude/rules/*.md` with `paths:` |
| **Skills** | Rules with `description:`, `.cursor/skills/` | `.claude/skills/*/SKILL.md` |
| **Manual prompts** | `.cursor/commands/*.md` | Skills with `disable-model-invocation` |
| **Ignore patterns** | `.cursorignore` | `permissions.deny` |
| **Full skill packages** | [AgentSkills.io](https://agentskills.io) format | AgentSkills.io format |

Things that translate cleanly just translate. Things that can't (like Claude's hooks, or Cursor commands that use `$ARGUMENTS`) get skipped with a clear warning telling you why. No silent data loss.

## Beyond Two Tools

a16n isn't hardwired to Cursor and Claude. It uses a plugin architecture: each tool is a plugin that knows how to read and write its own format. Cursor and Claude are built in. More can be added.

There's also a neutral format - the a16n IR - that you can convert to and from:

```bash
# Store your config in a tool-agnostic format
npx a16n convert --from cursor --to a16n

# Render it for any supported tool
npx a16n convert --from a16n --to claude
```

This makes a16n useful as a hub. Maintain one canonical set of agent customization and generate tool-specific configuration on demand - per developer, per project, per CI run.

Third-party plugins are auto-discovered from npm. If a package is named `a16n-plugin-*` and implements the plugin interface, `a16n` will find it. There's already one: [a16n-plugin-cursorrules](https://www.npmjs.com/package/a16n-plugin-cursorrules) adds support for the legacy `.cursorrules` format:

```bash
npm install -g a16n-plugin-cursorrules
npx a16n convert --from cursorrules --to cursor
```

## Useful Flags

A few things that came up during real use:

**Separate read/write directories.** Read from one project, write to another:

```bash
npx a16n convert --from cursor --to claude --from-dir ./proj-a --to-dir ./proj-b
```

**Path reference rewriting.** If your rule content references file paths (like `.cursor/rules/auth.mdc`), a16n can rewrite those references to point to the new locations:

```bash
npx a16n convert --from cursor --to claude --rewrite-path-refs
```

**Source cleanup.** Delete the source files after conversion (only if they were fully consumed - partially-converted sources are preserved):

```bash
npx a16n convert --from cursor --to claude --delete-source
```

**Git integration.** Control whether output files are tracked or ignored:

```bash
npx a16n convert --from cursor --to claude --gitignore-output-with match
```

## The Name

a16n is a numeronym, like i18n (internationalization) or l10n (localization). Smash "agent customization" together and count the letters between the first and last: a-[gentcustomizatio]-n. Sixteen. It's short, it's `npm`-able, and it was available.

## Status

a16n is [on npm](https://www.npmjs.com/package/a16n) at v0.13.0. I've been running it in my own workflow for a couple of weeks without incident. The [documentation](https://texarkanine.github.io/a16n/) covers the CLI, conversion semantics, and plugin development.

It's open source under AGPL-3.0 at [github.com/Texarkanine/a16n](https://github.com/Texarkanine/a16n). Contributions welcome - especially plugins for tools I don't use. If you're curious about how it got built, there's a [companion diary](/2026/03/13/seven-weeks.html).

If you have agent customization in one tool and wish you had it in another, give it a try:

```bash
npx a16n convert --from cursor --to claude --dry-run
```

The worst that happens is you see what would change.