DEV Community: Sriram Sureshkumar

How to Migrate from Cursor Rules to Agent Skills

Sriram Sureshkumar — Fri, 19 Jun 2026 23:10:00 +0000

Agent Skills are the open standard (agentskills.io) for packaging team-specific instructions that any AI coding tool can discover.

Migrating from hand-maintained Cursor rules means moving from static markdown you write once to structured, evidence-ranked intelligence your team already enforced in PR review — and (optionally) letting tooling generate the skill automatically.

Why migrate?

Cursor rules live only in Cursor's tree. Copilot wants .github/copilot-instructions.md. Claude Code reads CLAUDE.md. Maintaining the same conventions in four places doesn't scale.

Agent Skills provide one portable package. See what are Agent Skills for the full picture.

What you're migrating from

Legacy .cursorrules or .cursor/rules/*.mdc
Ad-hoc pasted instructions in chat
CONTRIBUTING.md sections nobody reads

What you're migrating to

.codehabits/conventions.json — structured, confidence-ranked
.cursor/skills/codehabits-team-intel/SKILL.md — Agent Skill auto-discovered by Cursor and compatible tools
AGENTS.md — fallback for agents that read AGENTS.md

Migration path (manual audit + auto-generate)

1. Audit existing rules

Export your current .cursor/rules files. Mark each rule as either:

Evidence-backed — appears in PR review
Aspirational — you wish the team did it but PRs don't enforce it

Automated extraction handles evidence-backed patterns; keep aspirational rules as short manual additions if needed.

2. Run Codehabits enable

npx @codehabits/cli login
npx @codehabits/cli enable

Compare generated conventions against your audit. You'll often find rules you forgot to document — and gaps where your written rules didn't match PR reality.

3. Commit intelligence to git

git add .codehabits/ .cursor/skills/ AGENTS.md
git commit -m "chore: migrate team conventions to Agent Skills"
git push

4. Deprecate duplicate rule files

Remove or slim down hand-written rules that now live in the generated skill. Keep only temporary or project-specific rules in .cursor/rules/. Document the change in your team channel so engineers know to pull latest.

5. Keep intelligence fresh

Set up CI auto-sync so merged PRs update conventions and regenerate the skill. Manual rules drift; PR-derived intelligence compounds.

Before and after

Hand-written Cursor rules	Codehabits Agent Skills
You write and maintain	Extracted from PR evidence
Cursor-only	Portable across 16+ tools
Static until someone edits	Syncs after each merged PR
No confidence scores	Ranked by review frequency

Related guides

Originally published at codehabits.dev.

Setting Up the Codehabits MCP Server in Cursor (5 Minutes)

Sriram Sureshkumar — Wed, 17 Jun 2026 23:08:00 +0000

The Codehabits MCP server gives Cursor six tools that read from .codehabits/ in your repo — convention lookup, code validation, domain knowledge, reviewer suggestions, and a feedback loop for updating conventions.

Setup takes about five minutes if you already ran codehabits enable.

Prerequisites

Node.js 20+
.codehabits/meta.json in your repo (from npx @codehabits/cli enable)
Cursor with MCP support enabled

If you don't have intelligence files yet, run enable first — see the quickstart.

Step 1: Install the MCP server

From your repository root:

npx @codehabits/cli mcp-install

This writes to .cursor/mcp.json. Commit it so teammates get the same config:

git add .cursor/mcp.json
git commit -m "chore: add codehabits MCP server"
git push

Step 2: Restart Cursor

MCP servers load at startup. Fully quit and reopen Cursor (or reload the window) before testing tools.

Step 3: Verify tools appear

Open Cursor Agent and check that the codehabits MCP server is connected. You should see these tools:

Tool	Purpose
`get_team_context`	Conventions and anti-patterns
`check_code`	Validate a snippet against team rules
`get_knowledge`	Domain knowledge by topic
`suggest_reviewers`	Expertise-based reviewer routing
`record_feedback` / `approve_proposal`	Propose and merge convention updates

Full reference: MCP server documentation.

Step 4: Use it in practice

Try these prompts in Cursor Agent:

"Use get_team_context for the api scope before writing this endpoint."
"Run check_code on this handler before I commit."
"Who should review changes to files under src/auth/? Use suggest_reviewers."

MCP vs Agent Skills

Agent Skills load passively when Cursor starts a task. MCP tools are explicit lookups — use them when you need validation or knowledge mid-task.

Most teams enable both: skills for baseline context, MCP for active checks.

One-prompt onboarding

The codehabits.dev/agents page has a bootstrap prompt that runs enable, mcp-install, and reads your intelligence files in one shot. Paste it when onboarding a new repo or teammate.

Troubleshooting

If tools return "No intelligence data available," confirm .codehabits/ exists and the MCP server's working directory is your repo root. Run codehabits enable if files are missing.

Common fixes:

Symptom	Fix
Server not listed	Restart Cursor after editing `mcp.json`
Wrong conventions	Check MCP `cwd` is repo root, not a subfolder
Stale rules	Run `npx @codehabits/cli sync`

What is Codehabits?

Codehabits extracts team coding conventions from GitHub PR history and delivers them to AI tools via Agent Skills and MCP — so your whole team shares the same evidence-backed patterns, not hand-maintained rule files.

Originally published at codehabits.dev.

Cursor Rules Not Working? Here's Why (And the Fix)

Sriram Sureshkumar — Mon, 15 Jun 2026 23:04:57 +0000

If Cursor rules aren't working, you're not alone. You wrote .cursor/rules (or a legacy .cursorrules file) telling the agent to use named exports, Zod validation, and your error-handling pattern — and the agent still generates default exports and skips validation.

This usually means one of three things:

The rules file is in the wrong place or format
The rules are too vague for the model to prioritize
The conventions you wrote don't match what your team actually enforces in PR review

Cursor rules are static instructions you maintain by hand. They don't learn from your PR history unless you rebuild them constantly.

Symptom: Cursor ignores your rules

This is the most common complaint from teams adopting AI coding tools. The agent has strong defaults; your rules compete with open files, chat history, and generic model behavior.

Cause 1: Wrong file location or format

Cursor has moved from a single .cursorrules file to the .cursor/rules/ directory with individual rule files. If your rules live in the old location, newer Cursor versions may not load them consistently.

Fix: Check Cursor's docs for your version and migrate to the current rules directory structure.

Cause 2: Rules compete with everything else

Vague rules like "write clean code" lose against strong defaults. Specific, evidence-backed rules work better — but writing them for every convention your team enforces takes hours and drifts out of date.

I wrote more about this dynamic in why AI tools ignore your team's patterns.

Cause 3: Rules don't match PR reality

The gap between what you think your team does and what PR review actually enforces is large. A rule file written by one engineer often misses conventions that only appear in review comments — the named-export preference, the ban on console.log, the custom error base class.

Without PR-derived evidence, rules are guesswork.

The fix: evidence-ranked team intelligence

Instead of hand-writing rules forever, extract conventions from merged and closed PRs where your team already enforced them.

Codehabits analyzes review comments and code patterns, ranks each convention by confidence, and writes structured intelligence to .codehabits/ plus an Agent Skill that Cursor auto-discovers:

npx @codehabits/cli enable
git add .codehabits/ .cursor/skills/ AGENTS.md
git commit -m "chore: add team intelligence"
git push

Teammates clone the repo and Cursor picks up the same skill — no per-developer rule files, no copy-paste.

(Free for individuals and OSS repos; team workspaces have a trial on codehabits.dev/pricing.)

When hand-written rules still make sense

Project-specific one-offs (a migration in progress, a temporary API freeze) belong in explicit rules. Team-wide conventions that repeat in every PR belong in intelligence extracted from evidence.

Use both: keep short-lived rules in .cursor/rules/ and let automated extraction own the long-lived patterns.

Next steps

Quickstart — enable in ~5 minutes
Migrate from Cursor rules to Agent Skills
Add MCP for real-time convention checks

Originally published at codehabits.dev.