Cursor Rules, Claude Code Skills, Windsurf Rules, AGENTS.md: One Pack, Four Formats

The short version: developers now run two or more coding agents — Cursor next to Claude Code, Windsurf for a client repo, Codex for a side project — and every one of them wants its rules in a different format. RulePort compiles one canonical rule set into all of them, with an installer and a drift check. Details below.

The Multi-Agent Reality

Two years ago the question was which coding agent to pick. In 2026 the question is which ones you are running today, and the honest answer for most working developers is at least two. I keep Cursor for refactoring in one repo, Claude Code in the terminal for anything touching the shell, and Windsurf for a client codebase that standardized on it. Switching is fine. The part that is not fine is that every switch loses the rules I spent months learning to write.

Those rules are the boring discipline stuff: verify a change before declaring it done, write the test first, never touch a database without a backup plan, review your own diff before shipping it. None of it is clever. All of it is why agent-written code is usable at all. And none of it travels.

Four Formats, One Set of Rules

Each tool reads instructions from its own location and its own syntax:

Tool	Where it wants rules
Cursor	.cursor/rules/*.mdc
Claude Code	skills/*/SKILL.md + CLAUDE.md
Windsurf	.windsurf/rules/*.md
Codex / OpenCode / Copilot CLI	a single AGENTS.md

That is four incompatible destinations for the same thinking. The 2026 comparison guides all land on the same consensus: these formats do not convert between each other. Your .cursorrules does not automatically become a Claude Code skill — you re-author it. So the working options today are all some flavor of bad.

Option one: maintain it by hand. Keep the same rules in three or four places, re-sync them whenever you refine one, and accept that the Cursor version is a little sharper than the Windsurf version because you edited that one last week.

Option two: the free alternative — awesome-list link dumps. Useful for discovery, stale in practice. The biggest one went months without an update, which means you are pasting rules written for an older version of a tool into a newer one.

Option three: paid packs on Gumroad, typically $9 to $59, usually holding one to three ratings. They are file dumps for a single tool: no installer, no way to regenerate when the tool's format moves, no drift check against what you installed.

None of these solve the actual problem, which is that rules are written repeatedly, not once.

Write your rules once, run them everywhere

RulePort is cross-runtime rule portability: one canonical rule set, compiled into every agent's native format, installed by one command.

One source of truth, four outputs

The pack ships 12 canonical rule files — that is the single source of truth. Running ruleport.py compile regenerates the Cursor .mdc rules, the Claude Code skills plus CLAUDE.md, the Windsurf rules, and a single AGENTS.md that covers Codex, OpenCode, Copilot CLI, and Aider as a fallback. Edit a rule once, recompile, and every agent has the new version. When a tool changes its format, that is a recompile against an updated compiler — not a rewrite of your rules.

A real installer, not a file dump

install.sh detects which agents are actually present (~/.claude, ./.cursor, ./.windsurf, ./AGENTS.md) and installs only into those. --dry-run prints exactly what it would write before writing anything. It is idempotent: re-run it any time and nothing piles up, and it never overwrites a file it did not write itself.

Drift detection

Stale rules are the quiet failure mode — an agent happily following guidance you fixed three updates ago. ruleport.py diff compares installed files against the pack: exit 0 means in sync, exit 1 means drift. Wire it into a pre-commit hook or a cron job and agents never silently run on old rules.

The 12 rules

verify-before-done, test-first, error handling, types & docstrings, security baseline, self code review, database safety, API design, dependency hygiene, git hygiene, frontend UI/a11y, and docs updates. These are exactly the disciplines that prevent the classic AI-code failures — the confident "done" with untested code, the swallowed exception, the dependency added for a problem the standard library already solved.

Zero-friction tech

Python 3.8+ and the standard library. No pip installs, no network access, no telemetry — the compile step runs offline, on your machine, against your files. The whole package is 58 files, about 100 KB as a zip, plus docs/customization.md for team conventions and docs/update-policy.md for breaking format changes.

Price

$1 at intro launch, against a field of $9–$59 single-tool packs. Free updates when agent formats change, delivered through your Gumroad receipt link — buy once, recompile forever.

Try It

Disclosure: this post promotes a product we made. We earn the money directly, no third-party commission, and we wrote this article so you can decide whether the problem is real for you before spending a dollar.

RulePort is on Gumroad at https://nandminc.gumroad.com/l/xcbqxr — $1 intro price, 58 files, includes the docs and free format updates. Questions first? Email nandminc2020@gmail.com. License in one line: personal and commercial use is allowed, including inside organizations and for client work; resale or redistribution of the pack or its files as a standalone product or inside another rules/skills collection is not.

FAQ

Does it replace my .cursorrules? Effectively yes. Modern Cursor reads .mdc rules, which is one of RulePort's four compiled outputs — the old single-file approach becomes redundant.

Do I need to install anything? Only Python 3.8+ and bash. No pip packages, no network access, nothing running in the background.

Questions or war stories from your own multi-agent setup: nandminc2020@gmail.com. For more AI tool deep-dives on AI Stack Lab, start at aistacklab2026.blogspot.com.