# /create-skill

## Purpose

Generate a new Claude Skill with proper structure and YAML frontmatter using official documentation as reference

## Contract

**Inputs:**

- `$1` — SKILL_NAME (lowercase, kebab-case, max 64 characters)
- `$2` — DESCRIPTION (what the skill does and when to use it, max 1024 characters)
- `--personal` — create in ~/.claude/skills/ (default)
- `--project` — create in .claude/skills/

**Outputs:** `STATUS=<CREATED|EXISTS|FAIL> PATH=<path>`

## Instructions

1. **Validate inputs:**
   - Skill name: lowercase letters, numbers, hyphens only
   - Description: non-empty, max 1024 characters

2. **Determine target directory:**
   - Personal (default): `~/.claude/skills/{{SKILL_NAME}}/`
   - Project: `.claude/skills/{{SKILL_NAME}}/`

3. **Generate SKILL.md using this template:**
   [template content here...]
```

<Alert type="tip" title="Key Insight">
  Commands are just instructions for Claude. Write them like you're teaching a
  junior developer the exact steps to follow. Good{" "}
  <InternalLink slug="xml-tagged-prompts-framework-reliable-ai-responses">
    prompt engineering principles
  </InternalLink>{" "}
  apply here too.
</Alert>

Here's what the plugin generates when you run a command:

<Figure
  src={outputExample}
  alt="Example output showing a generated skill file with proper structure and frontmatter"
  caption="The plugin creates properly structured files with all the boilerplate handled"
  width={800}
/>

## Publishing to GitHub

Once I had it working locally, publishing was straightforward:

1. Push to GitHub
2. Users add the marketplace: `/plugin marketplace add alexanderop/claude-code-builder`
3. Users install: `/plugin install claude-code-builder@claude-code-builder`

No npm, no build step. Just GitHub.

## Try It Yourself

Ready to stop copy-pasting Claude Code boilerplate?

**Step 1: Install the plugin**

```bash
/plugin install claude-code-builder@claude-code-builder
```

**Step 2: Verify installation**

Check that the plugin is loaded:

```bash
/plugins
```

You should see `claude-code-builder` in the list.

<Figure
  src={plugins}
  alt="Claude Code plugins list showing claude-code-builder installed"
  caption="The plugin appears in your installed plugins list"
  width={600}
/>

**Step 3: Use the new commands**

You now have access to seven new commands. Try creating your first skill:

```bash
/create-skill commit-helper "Generate clear commit messages; use when committing"
```

<Figure
  src={commands}
  alt="All seven commands available in Claude Code after installing the plugin"
  caption="Seven new commands at your fingertips"
  width={600}
/>

That's it. You're now equipped to generate skills, agents, commands, and more—without touching the docs.

## What's Next?

I'm using this daily. Every time I think "I wish Claude could...", I run `/create-skill` instead of Googling docs.

Right now, I'm focused on workflow optimization: building Vue applications faster with Claude Code.

The question I'm exploring: How do I teach Claude Code to write good Vue applications?

I'm working on:

- Skills that encode Vue best practices
- Commands for common Vue patterns (composables, stores, components)
- Custom agents that understand Vue architecture decisions
- <InternalLink slug="what-is-model-context-protocol-mcp">
    MCP server integrations
  </InternalLink>
  for external tools

It's not just about speed. It's about teaching Claude Code the way I think about development.

Building tools that build tools. That's where it gets fun.

---

--- title: Building a Modular Monolith with Nuxt Layers: A Practical Guide description: Learn how to build scalable applications using Nuxt Layers to enforce clean architecture boundaries without the complexity of microservices. tags: ['nuxt', 'vue', 'architecture', 'typescript'] url: https://alexop.dev/posts/nuxt-layers-modular-monolith ---