Skip to content
Skills Library
AI & agents · Building & coding

dev-skillify

/dev-skillify

Create a new custom skill for the workspace. Guides the user through defining the skill's slug, trigger conditions, workflow steps, outputs, and anti-patterns. Use when the user says 'create a skill', 'new skill', 'add a skill', 'I need a custom skill', or wants to formalize a workflow as a reusable skill.

Repository
evo-nexus ↗
Licence
Apache-2.0
Last repository change
12.05.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 12.05.2026, without references to retired models or APIs.

Licence

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What it does and when to use it

Create a new custom skill for the workspace. Guides the user through defining the skill's slug, trigger conditions, workflow steps, outputs, and anti-patterns. Use when the user says 'create a skill', 'new skill', 'add a skill', 'I need a custom skill', or wants to formalize a workflow as a reusable skill.

Triggers from the description

create a skillnew skilladd a skillI need a custom skill
Original author description

Create a new custom skill for the workspace. Guides the user through defining the skill's slug, trigger conditions, workflow steps, outputs, and anti-patterns. Use when the user says 'create a skill', 'new skill', 'add a skill', 'I need a custom skill', or wants to formalize a workflow as a reusable skill.

How it works

  1. What You're Building
  2. When to Use This Skill
  3. When NOT to Use
  4. Step 1: Understand the Skill
  5. Step 2: Generate the SKILL.md
  6. Step 3: Add Helper Scripts (Optional)
  7. Step 4: Verify
  8. Skill Naming Convention
  9. Existing Skill Prefixes (Do Not Duplicate Domain)
  10. Important Notes
Original SKILL.md headings · 182 lines, 1,076 words
SKILL.md preview
---
name: dev-skillify
description: "Create a new custom skill for the workspace. Guides the user through defining the skill's slug, trigger conditions, workflow steps, outputs, and anti-patterns. Use when the user says 'create a skill', 'new skill', 'add a skill', 'I need a custom skill', or wants to formalize a workflow as a reusable skill."
---

# Create Custom Skill

Guide the user through creating a new custom skill that formalizes a reusable workflow.

## What You're Building

A custom skill is a `SKILL.md` file in `.claude/skills/custom-{slug}/` with the `custom-` prefix. It has:
- YAML frontmatter with `name` and `description` (the description is what Claude matches against user requests)
- A workflow Claude follows when the skill is invoked
- Optional helper scripts or templates inside the skill folder

Custom skills are gitignored (the `custom-` prefix triggers this) — they're personal to your workspace. If the user ever wants to publish the skill for others, it would need a non-`custom-` name and an entry in `.claude/rules/skills.md`; mention this only if it comes up.

## When to Use This Skill

- The user says "create a skill", "new skill", "add a skill"
- The user describes a workflow they want to reinvoke with one command
- The user wants to formalize an ad-hoc process before it's lost

## When NOT to Use

- The workflow is one-off and won't be repeated → don't skill it
- A skill for this already exists → use it instead (check with `ls .claude/skills/`)
- The task needs its own agent, not just a workflow → use `create-agent`
- The user wants a new slash command without a workflow → use `create-command`

## Step 1: Understand the Skill

Ask the user:
1. **What is the trigger?** When should Claude reach for this skill? (e.g., "review this PR for security", "generate a daily standup note")
2. **What slug?** Short, kebab-case. The final folder will be `custom-{slug}/`. Suggest one if the user doesn't have preference.
3. **What does it do?** The actual workflow — step by step.
4. **What does it produce?** File, report, summary, side effect — be explicit.
5. **What inputs does it need?** Args passed in, files it reads, external APIs, etc.
6. **Any anti-patterns?** Things the skill should explicitly NOT do (helps Claude stay focused).

If any answer is vague, push back once before writing. A skill built on fuzzy triggers won't get invoked correctly.

## Step 2: Generate the SKILL.md

Create `.claude/skills/custom-{slug}/SKILL.md`:

```markdown
---
name: custom-{slug}
description: "{one-line — what it does and when to use it. Include 2-3 trigger phrases verbatim.}"
---

# {Skill Title}

{One paragraph — what this skill accomplishes and why it exists.}

## When to Use

- {Explicit trigger phrase 1}
- {Explicit trigger phrase 2}
- {Situation that should invoke this skill}

## When NOT to Use

- {Adjacent scenario that should go elsewhere}
- {Edge case the skill doesn't handle}

## Inputs

- {What the user must provide}
- {What the skill reads from the workspace}

## Workflow

### Step 1 — {name}
{What to do, which tools to use, what to produce.}

### Step 2 — {name}
{...}

### Step 3 — {name}
{...}

## Output

{What the user sees when the skill finishes. Be concrete: file path, summary format, side effects.}

## Anti-patterns

- Do NOT {thing the skill must never do}
- Do NOT {common failure mode}

## Pairs With

- {Other skill or agent that commonly runs before/after}
```

**Description field is critical** — that's what Claude matches against user requests. Make it specific and include trigger phrases verbatim. Vague descriptions mean the skill never fires.

## Step 3: Add Helper Scripts (Optional)

If the skill needs reusable logic (Python, shell, templates), put them next to `SKILL.md`:

```
.claude/skills/custom-{slug}/
├── SKILL.md
├── scripts/
│   └── helper.py
└── templates/
    └── report.md
```

Reference them from the workflow with relative paths: `.claude/skills/custom-{slug}/scripts/helper.py`.

Don't add scripts unless the workflow actually needs them — most skills are just the `SKILL.md`.

## Step 4: Verify

Run a quick check:

```bash
ls -la .claude/skills/custom-{slug}/SKILL.md
head -5 .claude/skills/custom-{slug}/SKILL.md  # confirm frontmatter is valid
```

Then tell the user:
- Skill created: `custom-{slug}`
- Path: `.claude/skills/custom-{slug}/SKILL.md`
- Invoke it by describing the trigger in natural language, or explicitly `/custom-{slug}` if you also want a slash command (use `create-command` for that).
- To delete: `rm -rf .claude/skills/custom-{slug}/`

## Skill Naming Convention

| Pattern | Example | Purpose |
|---------|---------|---------|
| `custom-review-pr` | PR review | Code review helper |
| `custom-daily-note` | Daily note | Journaling workflow |
| `custom-vendor-check` | Vendor check | Ops check against a list |
| `custom-ship-report` | Ship report | Post-release comms |

Rules:
- Always use `custom-` prefix (required for gitignore)
- Use lowercase, hyphen-separated names
- Start with a verb or domain noun when it makes the purpose obvious
- Keep slugs short (2-3 words after prefix)
- Avoid names that collide with existing skills (check `ls .claude/skills/`)

## Existing Skill Prefixes (Do Not Duplicate Domain)

These prefixes already cover major domains — if the new skill fits, consider whether it belongs as a core skill (non-`custom-`) instead:

| Prefix | Domain |
|---|---|
| `dev-` | Engineering workflows |
| `fin-` | Finance |
| `legal-` | Legal / compliance |
| `hr-` | People / HR |
| `mkt-` | Marketing |
| `data-` | Data / BI |
| `pm-` | Product management |
| `cs-` | Customer success |
| `int-` | External integrations |
| `social-` | Social media |
| `ops-` | Operations |
| `create-` | Scaffolding (new agents, routines, etc.) |

If the user's skill clearly fits one of these and they want it permanent, suggest that and offer to drop the `custom-` prefix — but only if the user confirms, because that change pulls it out of gitignore and into the shared repo.

## Important Notes

- Custom skills (`custom-*`) are gitignored — they won't be pushed to the repo
- The `description` field in frontmatter is what Claude matches against — invest in it
- Skills are stateless — they run a workflow, they don't persist memory
- For persistent state, use an agent (with `create-agent`) or a ticket (with `create-ticket`)
- A skill can invoke agents via the `Agent` tool and other skills via `Skill` — compose freely
- If the workflow naturally pairs with a slash command, also run `create-command` with the same slug

## Anti-patterns

- Do NOT create skills for one-off tasks
- Do NOT write vague descriptions — they won't be matched
- Do NOT duplicate an existing skill's domain — read before writing
- Do NOT bake project-specific paths or credentials into the skill body — use env vars and `config/workspace.yaml`
- Do NOT skip the verification step

Versions

The database has no other skills named dev-skillify.

Database snapshot: 13.11.2026 · package version e7e0970a961b (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100create-integration
    Create a new custom integration (API/service wrapper) for the workspace. Guides the user through defining the integration's slug, display name, description, category, and required env keys. Writes .claude/skills/custom-int-{slug}/SKILL.md via POST /api/integrations/custom. Use…
  • 100skillify
    Turn a repeated multi-step workflow into a user skill for Claude Code and Codex; use when asked to make it a skill.
  • 100skillify
    Extract a reusable skill from a workflow you just finished. Use when you say `skillify this`, `save this as a skill`, or `make this proper`. Do NOT use to design a skill from a goal (use skillforge).
  • 100skillify
    Extract a reusable skill from a workflow you just finished. Use when you say `skillify this`, `save this as a skill`, or `make this proper`. Do NOT use to design a skill from a goal (use skillforge).
  • 100skillify
    Turn something you just did into a reusable skill and register it in the resolver. Use when the user says "skillify this", "make that a skill", or after completing a non-trivial procedure worth repeating.
  • 95skillify
    Capture a completed Codex workflow as a reusable SKILL.md package by analyzing session context plus optional session-collector evidence, interviewing the user with structured prompts, and writing a validated skill artifact. Use when the user asks to skillify or operationalize a repeatable process.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.