Rule Creator

Name: Rule Creator
Author: oimiragieo

oimiragieo/agent-studio

81 installs
36 repo stars
Updated July 14, 2026
oimiragieo/agent-studio

Helps with ai & agent building tasks.

About

rule-creator is a Claude Code skill for ai & agent building. It helps solo builders move faster with AI-assisted development.

rule-creator
AI & Agent Building
AI-coding skill

Rule Creator by the numbers

81 all-time installs (skills.sh)
Ranked #5,179 of 16,546 AI & Agent Building skills by installs in the Skillselion catalog
Data as of Aug 4, 2026 (Skillselion catalog sync)

npx skills add https://github.com/oimiragieo/agent-studio --skill rule-creator

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

[![Listed on Skillselion](https://skillselion.com/badge/skills/oimiragieo/agent-studio/rule-creator.svg)](https://skillselion.com/skills/oimiragieo/agent-studio/rule-creator)

Installs	81
repo stars	★ 36
Last updated	July 14, 2026
Repository	oimiragieo/agent-studio ↗

What it does

Helps with ai & agent building tasks.

Files

SKILL.mdMarkdownGitHub ↗

Rule Creator

Create rule files in .claude/rules/. Rules are auto-discovered by Claude Code and loaded into agent context.

Step 0: Check for Existing Rule

Before creating, check if rule already exists:

test -f .claude/rules/<rule-name>.md && echo "EXISTS" || echo "NEW"

If EXISTS → use Read to inspect the current rule file, then Edit to apply changes directly. Run the post-creation integration steps (Step 4) after updating.

If NEW → continue with Step 0.5.

Step 0.5: Companion Check

Before proceeding with creation, run the ecosystem companion check:

1. Use companion-check.cjs from .claude/lib/creators/companion-check.cjs 2. Call checkCompanions("rule", "{rule-name}") to identify companion artifacts 3. Review the companion checklist — note which required/recommended companions are missing 4. Plan to create or verify missing companions after this artifact is complete 5. Include companion findings in post-creation integration notes

This step is informational (does not block creation) but ensures the full artifact ecosystem is considered.

When to Use

Creating project-specific coding guidelines
Documenting framework conventions
Establishing team standards
Defining workflow protocols

Rule File Format

Rules are simple markdown files:

# Rule Name

## Section 1

- Guideline 1
- Guideline 2

## Section 2

- Guideline 3
- Guideline 4

Example: testing.md

# Testing

## Test-Driven Development

- Use TDD for new features and bug fixes (Red-Green-Refactor cycle)
- Write failing test first, then minimal code to pass, then refactor
- Never write production code without a failing test first

## Test Organization

- Add unit tests for utilities and business logic
- Add integration tests for API boundaries
- Keep tests deterministic and isolated (no shared state)
- Place test files in `tests/` directory mirroring source structure

Creation Workflow

Step 1: Validate Inputs

// Validate rule name (lowercase, hyphens only)
const ruleName = args.name.toLowerCase().replace(/[^a-z0-9-]/g, '-');

// Validate content is not empty
if (!args.content || args.content.trim().length === 0) {
  throw new Error('Rule content cannot be empty');
}

Step 2: Create Rule File

const rulePath = `.claude/rules/${ruleName}.md`;

// Format content as markdown
const content = args.content.startsWith('#')
  ? args.content
  : `# ${ruleName.replace(/-/g, ' ').replace(/\b\w/g, l => l.toUpperCase())}\n\n${args.content}`;

await writeFile(rulePath, content);

Mandatory: Register in index

pnpm index-rules

Verify total_rules count increased. Rule is invisible to agents until indexed.

Step 3: Verify Auto-Discovery

Rules in .claude/rules/ are automatically loaded by Claude Code. No manual registration needed.

// Verify file was created
const fileExists = await exists(rulePath);
if (!fileExists) {
  throw new Error('Rule file creation failed');
}

Step 4: Run Post-Creation Integration

const {
  runIntegrationChecklist,
  queueCrossCreatorReview,
} = require('.claude/lib/creators/creator-commons.cjs');

await runIntegrationChecklist('rule', rulePath);
await queueCrossCreatorReview('rule', rulePath, {
  artifactName: ruleName,
  createdBy: 'rule-creator',
});

Post-Creation Integration

After rule creation, run integration checklist:

const {
  runIntegrationChecklist,
  queueCrossCreatorReview,
} = require('.claude/lib/creators/creator-commons.cjs');

// 1. Run integration checklist
const result = await runIntegrationChecklist('rule', '.claude/rules/<rule-name>.md');

// 2. Queue cross-creator review
await queueCrossCreatorReview('rule', '.claude/rules/<rule-name>.md', {
  artifactName: '<rule-name>',
  createdBy: 'rule-creator',
});

// 3. Review impact report
// Check result.mustHave for failures - address before marking complete

Integration verification:

[ ] Rule file created in .claude/rules/
[ ] Rule is auto-discovered by Claude Code
[ ] Rule content is clear and actionable
[ ] No conflicts with existing rules

Usage Examples

Create Code Standards Rule

Skill({
  skill: 'rule-creator',
  args: `--name code-standards --content "# Code Standards

## Organization
- Prefer small, cohesive files over large ones
- Keep interfaces narrow; separate concerns by feature

## Style
- Favor immutability; avoid in-place mutation
- Validate inputs and handle errors explicitly"`,
});

Create Git Workflow Rule

Skill({
  skill: 'rule-creator',
  args: `--name git-workflow --content "# Git Workflow

## Commit Guidelines
- Keep changes scoped and reviewable
- Use conventional commits: feat:, fix:, refactor:, docs:, chore:

## Branch Workflow
- Create feature branches from main
- Never force-push to main/master"`,
});

Related Skills

skill-creator - Create detailed workflows (for complex guidance needing a full SKILL.md)
hook-creator - Create enforcement hooks that accompany governance rules

Iron Laws

1. Every artifact MUST have a companion schema — Rules without a schema have no contract for structured validation. Create a JSON schema in .claude/schemas/ if the rule produces structured output or has configurable parameters. 2. Every artifact MUST be wired to at least one agent — A rule not referenced by any agent or skill is orphaned. Verify the rule is relevant to at least one agent's context (rules in .claude/rules/ are auto-loaded, but domain-specific rules should be referenced in agent prompts). 3. Every artifact MUST be indexed in its catalog — Rules not tracked in the catalog are hard to discover and audit. Add an entry or verify presence in the appropriate catalog. 4. Every artifact MUST pass integration validation — Run node .claude/tools/cli/validate-integration.cjs <rule-path> before marking creation complete. A rule that fails validation may have broken references or conflicts. 5. Every artifact MUST record a memory entry — Write the rule creation pattern, decisions, and any issues to .claude/context/memory/ (learnings.md, decisions.md, issues.md). Without memory, the creation is invisible to future sessions.

Memory Protocol (MANDATORY)

Before starting: Read .claude/context/memory/learnings.md

After completing:

New rule pattern → .claude/context/memory/learnings.md
Rule creation issue → .claude/context/memory/issues.md
Guideline decision → .claude/context/memory/decisions.md

ASSUME INTERRUPTION: If it's not in memory, it didn't happen.

Cross-Reference: Creator Ecosystem

This skill is part of the Creator Ecosystem. When research uncovers gaps, trigger the appropriate companion creator:

Gap Discovered	Required Artifact	Creator to Invoke	When
Domain knowledge needs a reusable skill	skill	`Skill({ skill: 'skill-creator' })`	Gap is a full skill domain
Existing skill has incomplete coverage	skill update	`Skill({ skill: 'skill-updater' })`	Close skill exists but incomplete
Capability needs a dedicated agent	agent	`Skill({ skill: 'agent-creator' })`	Agent to own the capability
Existing agent needs capability update	agent update	`Skill({ skill: 'agent-updater' })`	Close agent exists but incomplete
Domain needs code/project scaffolding	template	`Skill({ skill: 'template-creator' })`	Reusable code patterns needed
Behavior needs pre/post execution guards	hook	`Skill({ skill: 'hook-creator' })`	Enforcement behavior required
Process needs multi-phase orchestration	workflow	`Skill({ skill: 'workflow-creator' })`	Multi-step coordination needed
Artifact needs structured I/O validation	schema	`Skill({ skill: 'schema-creator' })`	JSON schema for artifact I/O
User interaction needs a slash command	command	`Skill({ skill: 'command-creator' })`	User-facing shortcut needed
Repeated logic needs a reusable CLI tool	tool	`Skill({ skill: 'tool-creator' })`	CLI utility needed
Narrow/single-artifact capability only	inline	Document within this artifact only	Too specific to generalize

---

Ecosystem Alignment Contract (MANDATORY)

This creator skill is part of a coordinated creator ecosystem. Any artifact created here must align with and validate against related creators:

agent-creator for ownership and execution paths
skill-creator for capability packaging and assignment
tool-creator for executable automation surfaces
hook-creator for enforcement and guardrails
rule-creator and semgrep-rule-creator for policy and static checks
template-creator for standardized scaffolds
workflow-creator for orchestration and phase gating
command-creator for user/operator command UX

Cross-Creator Handshake (Required)

Before completion, verify all relevant handshakes:

1. Artifact route exists in .claude/CLAUDE.md and related routing docs. 2. Discovery/registry entries are updated (catalog/index/registry as applicable). 3. Companion artifacts are created or explicitly waived with reason. 4. validate-integration.cjs passes for the created artifact. 5. Skill index is regenerated when skill metadata changes.

Research Gate (Exa + arXiv — BOTH MANDATORY)

For new patterns, templates, or workflows, research is mandatory:

1. Use Exa for implementation and ecosystem patterns:

mcp__Exa__web_search_exa({ query: '<topic> 2025 best practices' })
mcp__Exa__get_code_context_exa({ query: '<topic> implementation examples' })

2. Search arXiv for academic research (mandatory for AI/ML, agents, evaluation, orchestration, memory/RAG, security):

Via Exa: mcp__Exa__web_search_exa({ query: 'site:arxiv.org <topic> 2024 2025' })
Direct API: WebFetch({ url: 'https://arxiv.org/search/?query=<topic>&searchtype=all&start=0' })

3. Record decisions, constraints, and non-goals in artifact references/docs. 4. Keep updates minimal and avoid overengineering.

arXiv is mandatory (not fallback) when topic involves: AI agents, LLM evaluation, orchestration, memory/RAG, security, static analysis, or any emerging methodology.

Regression-Safe Delivery

Follow strict RED -> GREEN -> REFACTOR for behavior changes.
Run targeted tests for changed modules.
Run lint/format on changed files.
Keep commits scoped by concern (logic/docs/generated artifacts).

'use strict';
/**
 * Post-execute hook for rule-creator
 * Auto-generated by enterprise-bundle-scaffolder
 *
 * Records metrics after skill execution.
 */

function postExecute(_context) {
  // Record execution metrics
  return { ok: true, skill: 'rule-creator' };
}

module.exports = { postExecute };

'use strict';
/**
 * Pre-execute hook for rule-creator
 * Auto-generated by enterprise-bundle-scaffolder
 *
 * Validates inputs before skill execution.
 */

function preExecute(context) {
  // Validate skill invocation context
  if (!context || typeof context !== 'object') {
    return { allow: true, message: 'rule-creator: no context to validate' };
  }
  return { allow: true };
}

module.exports = { preExecute };

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "title": "rule-creatorInput",
  "description": "Input schema for Creates rule files for the Claude Code framework. Rules are markdown files in .claude/rules/ that are auto-loaded by Claude Code.",
  "type": "object",
  "additionalProperties": true,
  "properties": {
    "target": {
      "type": "string",
      "description": "Target file or path for the skill to operate on"
    },
    "options": {
      "type": "object",
      "description": "Additional options for skill execution",
      "additionalProperties": true
    }
  }
}

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "title": "rule-creatorOutput",
  "type": "object",
  "additionalProperties": true,
  "properties": {
    "ok": {
      "type": "boolean"
    },
    "summary": {
      "type": "string"
    }
  }
}

#!/usr/bin/env node
'use strict';

const fs = require('node:fs');
const path = require('node:path');

function findProjectRoot() {
  let dir = __dirname;
  while (dir !== path.dirname(dir)) {
    if (fs.existsSync(path.join(dir, '.claude'))) return dir;
    dir = path.dirname(dir);
  }
  return process.cwd();
}

const PROJECT_ROOT = findProjectRoot();
const CLAUDE_DIR = path.join(PROJECT_ROOT, '.claude');
const RULES_DIR = path.join(CLAUDE_DIR, 'rules');

function parseArgs(argv) {
  const options = {};
  for (let i = 0; i < argv.length; i++) {
    const arg = argv[i];
    if (!arg.startsWith('--')) continue;
    const key = arg.slice(2);
    const next = argv[i + 1];
    const hasValue = next && !next.startsWith('--');
    options[key] = hasValue ? argv[++i] : true;
  }
  return options;
}

function createRule(options) {
  const name = String(options.name || '')
    .trim()
    .toLowerCase()
    .replace(/[^a-z0-9-]/g, '-');
  if (!name) throw new Error('Missing required --name');
  const content = String(options.content || '').trim();
  if (!content) throw new Error('Missing required --content');

  const rulePath = path.join(RULES_DIR, `${name}.md`);
  if (fs.existsSync(rulePath)) {
    return { ok: true, status: 'exists', path: rulePath };
  }

  const title = name.replace(/-/g, ' ').replace(/\b\w/g, l => l.toUpperCase());
  const finalContent = content.startsWith('#') ? content : `# ${title}\n\n${content}`;

  if (!fs.existsSync(RULES_DIR)) fs.mkdirSync(RULES_DIR, { recursive: true });
  fs.writeFileSync(rulePath, finalContent, 'utf8');

  // POST-CREATION INTEGRATION
  try {
    const learningsPath = path.join(CLAUDE_DIR, 'context', 'memory', 'learnings.md');
    if (fs.existsSync(learningsPath)) {
      fs.appendFileSync(
        learningsPath,
        `\n- Created new framework rule: ${name} (${new Date().toISOString().split('T')[0]})\n`,
        'utf8'
      );
    }
  } catch (err) {
    console.error(`Warning: Integration partial: ${err.message}`);
  }

  return { ok: true, action: 'create', path: rulePath };
}

function main() {
  const options = parseArgs(process.argv.slice(2));
  if (options.help || Object.keys(options).length === 0) {
    console.log('Rule Creator CLI\nUsage: --name <name> --content <markdown-content>');
    return;
  }

  const result = createRule(options);
  console.log(JSON.stringify(result, null, 2));
}

if (require.main === module) {
  try {
    main();
  } catch (err) {
    console.error(err.message);
    process.exit(1);
  }
}