playbooks

home / skills / gigaverse-app / skillet / metaskill-naming

metaskill-naming skill

/metaskill/skills/metaskill-naming

This skill brainstorms and validates plugin and atom names using neutral nouns and naming conventions to ensure consistent, memorable identifiers.

npx playbooks add skill gigaverse-app/skillet --skill metaskill-naming

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
7.4 KB
---
name: metaskill-naming
description: Brainstorm and validate names for plugins, skills, agents, and commands. Use when naming a new plugin, choosing atom names, validating naming conventions, or when user mentions "name plugin", "name skill", "naming convention", "brainstorm names", "what should I call", "plugin name", "good name for".
---

# Naming Plugins and Atoms

Brainstorm and validate names for plugins and their components (atoms = skills/agents/commands).

## The Core Convention

### Verb Form by Type

| Type | Grammatical Form | Meaning | Suffix Pattern |
|------|-----------------|---------|----------------|
| **Skill** | Gerund (-ing) | "the activity of..." | -ing |
| **Agent** | Agent noun | "one who does..." | -er, -or, role noun |
| **Command** | Imperative | "do this" | base verb |

### The Golden Rule

**Plugin name = Common prefix of all atoms = Neutral noun**

```
✅ GOOD prefix (noun):
   skillsmith-    → skillsmith-authoring, skillsmith-tester, /skillsmith-create
   codeforge-     → codeforge-reviewing, codeforge-reviewer, /codeforge-review
   datakit-       → datakit-processing, datakit-processor, /datakit-process

❌ BAD prefix (already verb-formed):
   skill-authoring-  → skill-authoring-??? (prefix is already -ing!)
   code-review-      → code-review-??? (prefix looks like imperative!)
```

### No Type Postfixes

```
✅ GOOD: metaskill-authoring, metaskill-tester
❌ BAD:  metaskill-authoring-skill, metaskill-tester-agent
```

The directory structure already indicates the type.

## Brainstorming Process

### Step 1: Identify the Domain

What is this plugin about? Write 3-5 words describing the core activity:
- "creating skills for Claude Code"
- "reviewing code for security"
- "managing database migrations"

### Step 2: Find Neutral Noun Candidates

Transform the domain into neutral noun forms:

| Domain | Noun Candidates |
|--------|-----------------|
| creating skills | skillsmith, skillforge, skillcraft, skillkit |
| reviewing code | codeforge, codescan, codeguard, codewatch |
| managing databases | datakit, dataforge, dbsmith, migrator |

**Naming patterns that work:**
- **-smith**: One who forges (skillsmith, codesmith)
- **-forge**: Place where things are made (skillforge, codeforge)
- **-craft**: The craft of making (skillcraft, codecraft)
- **-kit**: Toolkit for (skillkit, datakit)
- **-bench**: Workbench for (skillbench, codebench)
- **-works**: Workshop (skillworks, dataworks)
- **meta-**: Meta-level tools (metaskill, metadata)
- **-guard/-watch**: Protective monitoring (codeguard, datawatch)

### Step 3: Generate Atom Names

For each candidate prefix, generate the full set:

```
Prefix: skillsmith
├── Skills (-ing):
│   ├── skillsmith-authoring
│   ├── skillsmith-triggering
│   └── skillsmith-packaging
├── Agents (role noun):
│   ├── skillsmith-trigger-tester
│   └── skillsmith-quality-checker
└── Commands (imperative):
    ├── /skillsmith-create
    └── /skillsmith-test
```

### Step 4: Validate Names

Check each name against:

- [ ] **Prefix is neutral noun** - not a verb form
- [ ] **Skills end in -ing** - gerund form
- [ ] **Agents end in role noun** - -er/-or or natural role
- [ ] **Commands end in imperative** - base verb
- [ ] **No type postfixes** - no -skill, -agent, -command
- [ ] **Pronounceable** - can say it out loud
- [ ] **Memorable** - distinctive enough to remember
- [ ] **No conflicts** - doesn't clash with existing plugins

### Step 5: Test with Full Table

| Prefix | Skill | Agent | Command |
|--------|-------|-------|---------|
| skillsmith | skillsmith-authoring | skillsmith-author | /skillsmith-author |
| | skillsmith-triggering | skillsmith-trigger-tester | /skillsmith-trigger |
| | skillsmith-grouping | skillsmith-group-designer | /skillsmith-group |

Does the table look consistent? Do the names feel natural?

## Example: This Plugin

**Domain:** "meta-tooling for creating Claude Code skills"

**Brainstorming:**
- skillsmith, skillforge, skillcraft → good but generic
- metaskill → captures "meta" aspect, clear noun
- skillet → fun but might confuse with cooking

**Chosen:** `metaskill`

| Type | Name | Follows Convention? |
|------|------|---------------------|
| Plugin | metaskill | ✓ Neutral noun |
| Skill | metaskill-authoring | ✓ Ends in -ing |
| Skill | metaskill-triggering | ✓ Ends in -ing |
| Skill | metaskill-grouping | ✓ Ends in -ing |
| Skill | metaskill-packaging | ✓ Ends in -ing |
| Skill | metaskill-naming | ✓ Ends in -ing |
| Agent | metaskill-trigger-tester | ✓ Ends in role noun |

## Common Pitfalls

### 1. Verb-Form Prefix

```
❌ skill-authoring-trigger    # "skill-authoring" is already -ing
✅ metaskill-triggering       # "metaskill" is noun, "-triggering" is -ing
```

### 2. Awkward -ing Forms

When -ing sounds unnatural, rephrase the activity:

```
❌ metaskill-trigger          # Missing -ing
❌ metaskill-triggering       # Could mean "firing events"
✅ metaskill-triggering       # Context: "configuring triggers" (acceptable)
✅ metaskill-trigger-tuning   # Alternative: explicit "tuning"
```

### 3. Conflicting Meanings

Test if the name could mean something else:
- "triggering" → firing events? or configuring triggers?
- Context usually disambiguates, but consider alternatives if confusing

## Quick Reference Card

```
┌─────────────────────────────────────────────────────────────────┐
│                    NAMING CONVENTION                            │
├─────────────────────────────────────────────────────────────────┤
│  Plugin Name = Common Prefix = NEUTRAL NOUN                     │
│                                                                 │
│  ┌──────────┬────────────────────┬─────────────────────────┐   │
│  │   Type   │   Suffix Form      │   Example               │   │
│  ├──────────┼────────────────────┼─────────────────────────┤   │
│  │ Skill    │ -ing (gerund)      │ metaskill-authoring     │   │
│  │ Agent    │ -er/-or (role)     │ metaskill-trigger-tester│   │
│  │ Command  │ imperative verb    │ /metaskill-create       │   │
│  └──────────┴────────────────────┴─────────────────────────┘   │
│                                                                 │
│  ❌ NO type postfixes: -skill, -agent, -command                 │
│  ❌ NO verb-form prefixes: reviewing-, authoring-               │
└─────────────────────────────────────────────────────────────────┘
```

## Related Skills

- For skill structure and writing, see `/metaskill-authoring`
- For trigger optimization, see `/metaskill-triggering`
- For skill group patterns, see `/metaskill-grouping`
- For plugin packaging, see `/metaskill-packaging`

Overview

This skill helps you brainstorm and validate names for plugins, skills (atoms), agents, and commands following a clear, consistent convention. It produces neutral noun prefixes, generates matching -ing skills, role-noun agents, and imperative commands, then validates the set for clarity and conflicts. Use it to get memorable, pronounceable, and convention-compliant names quickly.

How this skill works

I start by identifying the domain in 3–5 words (what the plugin does). I transform that domain into neutral noun candidates (e.g., -smith, -forge, -kit, meta-). For each prefix I generate matching atom names: skills end with -ing, agents use role nouns (-er/-or), and commands use the base verb form. Finally, I validate names against a checklist: neutral prefix, correct suffixes, no type postfixes, pronounceability, memorability, and conflict risk.

When to use it

  • Naming a new plugin or deciding a shared prefix for related atoms
  • Brainstorming alternative neutral-prefix candidates (skillsmith, codeforge, datakit, metaskill)
  • Validating that existing names follow the convention and are consistent
  • Choosing atom names: -ing skills, -er/-or agents, and imperative commands
  • Checking for ambiguous or conflicting meanings before publishing

Best practices

  • Make the plugin name a neutral noun that serves as the common prefix (avoid verb-like prefixes)
  • Use -ing for skills, -er/-or or natural role nouns for agents, and base verbs for command routes
  • Avoid explicit type postfixes like -skill, -agent, or -command; the directory indicates type
  • Prefer short, pronounceable, and distinctive prefixes to improve recall
  • When -ing feels awkward, rephrase the activity (e.g., trigger-tuning vs. triggering)

Example use cases

  • Domain: creating skills → prefix ideas: skillsmith, skillforge, skillkit; atoms: skillsmith-authoring, /skillsmith-create
  • Domain: reviewing code → prefix ideas: codeforge, codeguard; atoms: codeforge-reviewing, codeforge-reviewer, /codeforge-review
  • Validate existing names: detect verb-form prefixes like skill-authoring- and recommend neutral alternatives
  • Generate a table of prefix → skill → agent → command to check consistency before release
  • Resolve ambiguous -ing meanings by suggesting clearer -ing or alternate role names

FAQ

What makes a prefix 'neutral' and why does it matter?

A neutral prefix is a noun (place, tool, or role) rather than a verb form. It matters because it stays stable as a common prefix for mixed atom types and avoids awkward double-verb constructions.

What if -ing sounds awkward for a particular activity?

Rephrase the activity into a clearer gerund or use a more specific noun role (e.g., trigger-tuning, trigger-designer) to avoid confusion.

Should I check for name conflicts globally?

Yes. After you shortlist names, search existing plugins and packages to avoid collisions and confusingly similar names.