rules-migration

Migrate CLAUDE.md into a modular .claude/rules directory structure.

2|Updated Dec 10, 2025
One-click install
npx skills add https://github.com/lisaross/claude-code-plugins --skill rules-migration
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: rules-migration
Source: https://github.com/lisaross/claude-code-plugins/tree/main/rules-migrate/skills/rules-migration
Command: npx skills add https://github.com/lisaross/claude-code-plugins --skill rules-migration

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Monolithic CLAUDE.md files often become unwieldy, making it difficult to manage project instructions, enforce path-specific guidelines, and collaborate effectively. This Skill automates the transformation of these large, unorganized files into a structured, modular rules system, eliminating manual refactoring effort and reducing complexity.

Core Features & Use Cases

  • Automated Migration: Effortlessly converts your existing CLAUDE.md into Claude Code's modular .claude/rules/ directory structure.
  • Path-Specific Rules: Enables the creation of rules that apply only to specific file paths or types (e.g., src/**/*.ts for backend code), ensuring context-aware guidance.
  • Enhanced Organization: Breaks down complex instructions into focused, manageable files, improving clarity, maintainability, and team collaboration.
  • Use Case: If your CLAUDE.md has grown into a sprawling document covering everything from frontend styling to backend API guidelines, use this Skill to automatically split it into logical, path-specific files like frontend/react.md, backend/api.md, and core.md, making project instructions instantly more accessible and actionable.

Quick Start

Migrate the current project's CLAUDE.md file into the new modular rules system.

Frequently Asked Questions about rules-migration

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I convert a large CLAUDE.md file into a modular rules structure?

Migrate your monolithic CLAUDE.md into Claude Code's `.claude/rules/` directory structure by splitting instructions into path-specific rule files. This automation preserves all content, organizes guidelines by context (frontend, backend, tests), and enables path-aware distribution across teams while maintaining auditability.

What are path-specific rules and how do they improve project organization?

Path-specific rules apply instructions only to designated file paths or types using glob patterns—for example, `src/**/*.ts` for backend code. This approach eliminates monolithic guidance, ensures context-aware compliance, and lets different teams maintain separate guidelines within a single project without manual coordination.

Can I organize different guidelines for frontend, backend, and test directories?

Yes. The modular rules system splits your CLAUDE.md into separate path-bound files like `frontend/react.md`, `backend/api.md`, and `core.md`. Each file targets specific directories and file types, making project instructions instantly accessible and actionable across frontend, backend, tests, and shared memory contexts.

Does this migration preserve the content and structure of my existing CLAUDE.md?

Migration fully preserves all existing content while restructuring it into organized, path-specific rule files with frontmatter. The process enforces separation between global and path-specific rules, maintains auditability throughout, and supports ongoing maintenance without information loss.

What workflow automation benefits does modularization provide for multi-team projects?

Modular rules enable automated, path-aware rule distribution across teams, reducing manual coordination overhead. Each team accesses only relevant guidelines for their domain, enforcement becomes context-specific, and the system scales without sprawling documentation that grows difficult to maintain.

Why should I split CLAUDE.md instead of keeping everything in one file?

Monolithic CLAUDE.md files become unwieldy and hard to maintain as projects grow. Splitting into modular, path-specific rules eliminates complexity, improves clarity for team collaboration, enables granular path-aware guidance, and reduces refactoring effort when guidelines need updates or reorg across domains.