creating-claude-rules
Use when creating or fixing .claude/rules/ files - provides correct paths frontmatter (not globs), glob patterns, and avoids Cursor-specific fields like alwaysApply
Best use case
creating-claude-rules is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Use when creating or fixing .claude/rules/ files - provides correct paths frontmatter (not globs), glob patterns, and avoids Cursor-specific fields like alwaysApply
Teams using creating-claude-rules should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/creating-claude-rules-skill/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How creating-claude-rules Compares
| Feature / Agent | creating-claude-rules | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Use when creating or fixing .claude/rules/ files - provides correct paths frontmatter (not globs), glob patterns, and avoids Cursor-specific fields like alwaysApply
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
Related Guides
SKILL.md Source
# Creating Claude Rules
## Overview
Rules in `.claude/rules/` are modular instructions scoped to specific files via glob patterns. They load automatically with same priority as `CLAUDE.md`.
## When to Use
- Creating new rules in `.claude/rules/`
- Fixing rules that use wrong frontmatter (`globs` instead of `paths`)
- Migrating Cursor rules to Claude format
- Organizing project-specific conventions
## Quick Reference
| Field | Claude | Cursor |
|-------|--------|--------|
| Path patterns | `paths` | `globs` |
| Always apply | Omit `paths` | `alwaysApply: true` |
| Description | Not documented | `description` |
## Frontmatter
### Path-Scoped Rules
```yaml
---
paths:
- "src/api/**/*.ts"
- "tests/**/*.test.ts"
---
```
Or single pattern:
```yaml
---
paths: src/**/*.{ts,tsx}
---
```
### Global Rules
Omit frontmatter entirely - applies to all files:
```markdown
# TypeScript Conventions
Use .js extensions in imports.
```
## Common Mistakes
```yaml
# ❌ WRONG - globs is Cursor format
---
globs:
- "**/*.ts"
---
# ✅ CORRECT - Claude uses paths
---
paths:
- "**/*.ts"
---
```
```yaml
# ❌ WRONG - alwaysApply is Cursor-only
---
alwaysApply: true
---
# ✅ CORRECT - just omit paths for global rules
# (no frontmatter needed)
```
```yaml
# ❌ WRONG - unquoted patterns
---
paths:
- **/*.ts
---
# ✅ CORRECT - quote glob patterns
---
paths:
- "**/*.ts"
---
```
## Directory Structure
```
.claude/rules/
├── testing.md # Path-scoped or global
├── typescript.md
└── frontend/ # Subdirectories supported
└── react.md
```
Files discovered recursively. Use subdirectories to organize.
## Glob Patterns
| Pattern | Matches |
|---------|---------|
| `**/*.ts` | All .ts files anywhere |
| `src/**/*` | Everything under src/ |
| `*.md` | Markdown in root only |
| `**/*.{ts,tsx}` | .ts and .tsx files |
| `{src,lib}/**/*.ts` | .ts in src/ or lib/ |
## Reference
https://code.claude.com/docs/en/memory#modular-rules-with-claude/rules/Related Skills
creating-skills
Use when creating new Claude Code skills or improving existing ones - ensures skills are discoverable, scannable, and effective through proper structure, CSO optimization, and real examples
creating-claude-hooks
Use when creating or publishing Claude Code hooks - covers executable format, event types, JSON I/O, exit codes, security requirements, and PRPM package structure
creating-claude-agents
Use when creating or improving Claude Code agents. Expert guidance on agent file structure, frontmatter, persona definition, tool access, model selection, and validation against schema.
creating-agent-skills-skill
Use when creating Agent Skills packages (SKILL.md format) for Codex CLI, GitHub Copilot, or Amp - provides the agentskills.io specification with frontmatter constraints, directory structure, and validation rules
agent-relay-orchestrator
Run headless multi-agent orchestration sessions via Agent Relay. Use when spawning teams of agents, creating channels for coordination, managing agent lifecycle, and running parallel workloads across Claude/Codex/Gemini/Pi/Droid agents.
adding-swarm-patterns
Use when adding new multi-agent coordination patterns to agent-relay - provides checklist for types, schema, templates, and docs updates
agent-relay
Use when you need Codex to coordinate multiple agents through Relaycast for peer-to-peer messaging, lead/worker handoffs, or shared status tracking across sub-agents and terminals.
openclaw-relay
Real-time messaging across OpenClaw instances (channels, DMs, threads, reactions, search).
prpm-json-best-practices
Best practices for structuring prpm.json package manifests with required fields, tags, organization, multi-package management, enhanced file format, eager/lazy activation, and conversion hints
implementing-command-palettes
Use when building Cmd+K command palettes in React - covers keyboard navigation with arrow keys, keeping selected items in view with scrollIntoView, filtering with shortcut matching, and preventing infinite re-renders from reference instability
github-oauth-nango-integration
Use when implementing GitHub OAuth + GitHub App authentication with Nango - provides two-connection pattern for user login and repo access with webhook handling
frontend-design
Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.