Command Creator

Name: Command Creator
Author: oimiragieo

oimiragieo/agent-studio

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

Helps with ai & agent building tasks.

About

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

command-creator
AI & Agent Building
AI-coding skill

Command Creator by the numbers

49 all-time installs (skills.sh)
Ranked #7,329 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 command-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/command-creator.svg)](https://skillselion.com/skills/oimiragieo/agent-studio/command-creator)

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

What it does

Helps with ai & agent building tasks.

Files

SKILL.mdMarkdownGitHub ↗

Command Creator

Create command files that delegate to skills. Commands live in .claude/commands/ and are auto-discovered by Claude Code as /commandname.

Step 0: Check for Existing Command

Before creating, check if command already exists:

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

If EXISTS → use Read to inspect the current command 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("command", "{command-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 user-facing shortcuts to skills
Simplifying complex skill invocations
Providing memorable command names for common workflows

Command File Format

All commands use this pattern:

---
description: Brief description of what this command does
disable-model-invocation: true
---

Invoke the {skill-name} skill and follow it exactly as presented to you

Example: `/tdd` command

---
description: Test-driven development workflow with Iron Laws
disable-model-invocation: true
---

Invoke the tdd skill and follow it exactly as presented to you

Creation Workflow

Step 1: Validate Inputs

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

// Validate target skill exists
const skillExists = await fileExists(`.claude/skills/**/${args.skill}/SKILL.md`);
if (!skillExists) {
  throw new Error(`Target skill not found: ${args.skill}`);
}

Step 2: Create Command File

const commandPath = `.claude/commands/${commandName}.md`;
const description = args.description || `Invoke the ${args.skill} skill`;

const content = `---
description: ${description}
disable-model-invocation: true
---

Invoke the ${args.skill} skill and follow it exactly as presented to you
`;

await writeFile(commandPath, content);

Step 3: Update Command Catalog

const catalogPath = '.claude/context/artifacts/catalogs/command-catalog.md';
const catalogContent = await readFile(catalogPath, 'utf-8');

// Add entry to catalog
const newEntry = `| /${commandName} | ${description} | ${args.skill} |`;

// Insert alphabetically

Step 4: Run Post-Creation Integration

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

await runIntegrationChecklist('command', commandPath);
await queueCrossCreatorReview('command', commandPath, {
  artifactName: commandName,
  createdBy: 'command-creator',
});

Post-Creation Integration

After command creation, run integration checklist:

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

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

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

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

Integration verification:

[ ] Command added to command-catalog.md
[ ] Target skill exists and is valid
[ ] Command file has proper YAML frontmatter
[ ] Command is discoverable via /commandname

Usage Examples

Create TDD Command

Skill({
  skill: 'command-creator',
  args: '--name tdd --skill tdd --description "Test-driven development workflow"',
});

Create Debug Command

Skill({
  skill: 'command-creator',
  args: '--name debug --skill debugging --description "Systematic debugging workflow"',
});

Related Skills

skill-creator - Create the skills that commands delegate to
skill-updater - Update the underlying skill a command delegates to

Memory Protocol (MANDATORY)

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

After completing:

New command pattern → .claude/context/memory/learnings.md
Command creation issue → .claude/context/memory/issues.md
Delegation 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 command-creator
 * Auto-generated by enterprise-bundle-scaffolder
 *
 * Records metrics after skill execution.
 */

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

module.exports = { postExecute };

'use strict';
/**
 * Pre-execute hook for command-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: 'command-creator: no context to validate' };
  }
  return { allow: true };
}

module.exports = { preExecute };

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "title": "command-creatorInput",
  "description": "Input schema for Creates command files for the Claude Code framework. Commands are user-facing shortcuts that delegate to skills.",
  "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": "command-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 COMMANDS_DIR = path.join(CLAUDE_DIR, 'commands');

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 updateRoutingTableKeywords(name, description) {
  const filePath = path.join(
    PROJECT_ROOT,
    '.claude',
    'lib',
    'routing',
    'routing-table-intent-keywords.cjs'
  );
  if (!fs.existsSync(filePath)) return;
  let content = fs.readFileSync(filePath, 'utf8');
  if (content.includes(`'${name}':`)) return;

  const keywords = Array.from(
    new Set([name, ...name.split('-'), ...(description.toLowerCase().match(/\b\w{4,}\b/g) || [])])
  ).slice(0, 10);

  const entry = `  '${name}': ${JSON.stringify(keywords, null, 2).replace(/\]/g, '],')},`;
  const insertionPoint = content.lastIndexOf('};');
  if (insertionPoint !== -1) {
    content = content.slice(0, insertionPoint) + entry + '\n' + content.slice(insertionPoint);
    fs.writeFileSync(filePath, content, 'utf8');
  }
}

function updateRoutingTableAgents(name, skill) {
  const filePath = path.join(
    PROJECT_ROOT,
    '.claude',
    'lib',
    'routing',
    'routing-table-intent-agents.cjs'
  );
  if (!fs.existsSync(filePath)) return;
  let content = fs.readFileSync(filePath, 'utf8');
  if (content.includes(`'${name}':`)) return;

  // Commands usually route to the skill name as an intent
  const entry = `  '${name}': '${skill}',`;
  const insertionPoint = content.lastIndexOf('};');
  if (insertionPoint !== -1) {
    content = content.slice(0, insertionPoint) + entry + '\n' + content.slice(insertionPoint);
    fs.writeFileSync(filePath, content, 'utf8');
  }
}

function updateCommandCatalog(name, description, skill) {
  const catalogPath = path.join(
    CLAUDE_DIR,
    'context',
    'artifacts',
    'catalogs',
    'command-catalog.md'
  );
  if (!fs.existsSync(catalogPath)) return;
  let content = fs.readFileSync(catalogPath, 'utf8');
  if (content.includes(`/${name}`)) return;

  const entry = `| /${name} | ${description} | ${skill} |`;
  const tableHeader = '| Command | Description | Target Skill |';
  const idx = content.indexOf(tableHeader);
  if (idx !== -1) {
    const tableStart = content.indexOf('\n', idx) + 1;
    const separatorLine = content.indexOf('\n', tableStart) + 1;
    content = content.slice(0, separatorLine) + entry + '\n' + content.slice(separatorLine);
    fs.writeFileSync(catalogPath, content, 'utf8');
  }
}

function createCommand(options) {
  const name = String(options.name || '')
    .trim()
    .toLowerCase()
    .replace(/[^a-z0-9-]/g, '-');
  if (!name) throw new Error('Missing required --name');
  const skill = String(options.skill || '').trim();
  if (!skill) throw new Error('Missing required --skill');
  const description = String(options.description || `Invoke the ${skill} skill`).trim();

  const commandPath = path.join(COMMANDS_DIR, `${name}.md`);
  if (fs.existsSync(commandPath)) {
    console.log(`Command already exists: ${commandPath}`);
    return { ok: true, status: 'exists' };
  }

  const content = `---
description: ${description}
disable-model-invocation: true
verified: true
lastVerifiedAt: ${new Date().toISOString()}
---

Invoke the ${skill} skill and follow it exactly as presented to you
`;

  if (!fs.existsSync(COMMANDS_DIR)) fs.mkdirSync(COMMANDS_DIR, { recursive: true });
  fs.writeFileSync(commandPath, content, 'utf8');

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

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

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

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

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

Related skills

Setup Matt Pocock SkillsScaffold the per-repo configuration that Matt Pocock’s engineering agent skills rely on so they understand the issue tracker, triage labels, and domain documentation la495k196k

Lark AppsConnect Claude, Cursor or custom agents directly to Lark (Feishu) for messaging, document automation, approval workflows and enterprise data access.402k

CavemanSlash token usage by roughly 75% while keeping every technical detail intact when working with Claude Code, Cursor or similar agents.391k94.7k

Lark Skill MakerQuickly turn any Lark/Feishu OpenAPI call or multi-step workflow into a reusable agent skill with its own SKILL.md.386k16k

Running Claude Code Via Litellm CopilotRun Claude Code at a fraction of the cost by routing requests through LiteLLM to the GitHub Copilot Chat API.270k72

Codex PetGenerate a complete Codex Pet spritesheet and metadata from one reference image without needing an OpenAI key or Codex Pro.246k10

AI & Agent Buildingagents

Command Creator

About

Command Creator by the numbers

Add your badge

What it does

Files

Command Creator

Step 0: Check for Existing Command

Step 0.5: Companion Check

When to Use

Command File Format

Creation Workflow

Step 1: Validate Inputs

Step 2: Create Command File

Step 3: Update Command Catalog

Step 4: Run Post-Creation Integration

Post-Creation Integration

Usage Examples

Create TDD Command

Create Debug Command

Related Skills

Memory Protocol (MANDATORY)

Cross-Reference: Creator Ecosystem

Ecosystem Alignment Contract (MANDATORY)

Cross-Creator Handshake (Required)

Research Gate (Exa + arXiv — BOTH MANDATORY)

Regression-Safe Delivery

command-creator Research Requirements

Skill Description

Research Areas

Source References

command-creator Rules

Purpose

Best Practices

Integration Points

command-creator Implementation Template

Goal

TDD

Verification

Related skills

About

Command Creator by the numbers

Add your badge

What it does

Files

Command Creator

Step 0: Check for Existing Command

Step 0.5: Companion Check

When to Use

Command File Format

Creation Workflow

Step 1: Validate Inputs

Step 2: Create Command File

Step 3: Update Command Catalog

Step 4: Run Post-Creation Integration

Post-Creation Integration

Usage Examples

Create TDD Command

Create Debug Command

Related Skills

Memory Protocol (MANDATORY)

Cross-Reference: Creator Ecosystem

Ecosystem Alignment Contract (MANDATORY)

Cross-Creator Handshake (Required)

Research Gate (Exa + arXiv — BOTH MANDATORY)

Regression-Safe Delivery

command-creator Research Requirements

Skill Description

Research Areas

Source References

command-creator Rules

Purpose

Best Practices

Integration Points

command-creator Implementation Template

Goal

TDD

Verification

Related skills

This week in AI coding