Skip to main content
skill CX Codex

building-skills-from-patterns — Claude Code skill: how to install

Turns repeated multi-step workflows into reusable SKILL.md files. It triggers when an agent re-derives the same routine or needs the same user correction three times.

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add spencerpauly/awesome-cursor-skills --skill building-skills-from-patterns -a claude-code
Open on GitHub

What building-skills-from-patterns does

This meta-skill watches how you interact with the agent across the repository. When you repeat the same routine three times or the agent keeps recalculating steps, it intervenes. The skill captures that exact workflow into a standalone SKILL.md file. It records imperative steps and CLI tools such as npm or gh.

Each generated skill includes invocation triggers, step-by-step instructions, and safety notes. It checks that commands contain no API keys or machine-specific paths before saving. Do not use this for always-on coding style policies. Static repository guidelines belong in .cursor/rules/, because skills handle on-demand multi-step execution.

The prompt enforces one skill per workflow, avoiding bloated all-in-one documents. If the routine changes later, the agent updates the existing file instead of creating duplicates. It informs you of the new file path right away, so the workspace picks it up on the next session.

What it helps with

  • extract repeated terminal workflows into SKILL.md files
  • capture user corrections into reusable agent routines
  • strip local file paths and credentials from generated steps
  • separate on-demand procedures from static repository rules

Example prompts for the agent

  • We ran lint, tsc, and test before commit three times now. Turn this into a reusable skill.
  • Save our preview branch deployment workflow as a new SKILL.md.
  • building-skills-from-patterns: package our API verification steps into a skill file

How to install building-skills-from-patterns

1Skills CLI (Vercel)

npx skills add spencerpauly/awesome-cursor-skills --skill building-skills-from-patterns -a claude-code

2Manually: put the files in place

~/.claude/skills/building-skills-from-patterns/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/building-skills-from-patterns/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about building-skills-from-patterns

How do I install building-skills-from-patterns in Claude Code?

Run npx skills add spencerpauly/awesome-cursor-skills --skill building-skills-from-patterns -a claude-code in your terminal. This downloads the file to ~/.claude/skills/building-skills-from-patterns/SKILL.md.

What does building-skills-from-patterns do?

It monitors repetitive steps during your coding sessions. When a workflow repeats three times, the agent packages it into a formatted markdown skill for future sessions to load.

How do skills differ from rules and hooks?

Skills execute on demand for procedures with tool calls and branching logic. Rules in .cursor/rules/ enforce always-on coding style, while hooks in .cursor/hooks.json trigger automatically on file saves or stop events.

Source text

SKILL.md · CC0-1.0
---
name: building-skills-from-patterns
description: When the same multi-step workflow repeats in Cursor (user corrections or agent redos), capture it as a new SKILL.md under .cursor/skills/ so future sessions load it automatically.
user-invocable: true
---

# Building Skills From Patterns

**Skills** are reusable `SKILL.md` files. This meta-skill tells the agent to **promote repeated muscle memory** into a named skill: research once, encode the workflow, reuse forever.

## When to trigger

- The user has asked for the **same sequence** three or more times (e.g. “always run lint then tsc then test before commit”).
- The agent notices it is **re-deriving** the same steps on every task in this repo (e.g. “how we deploy preview branches”).
- A correction sounds like a **policy** (“never use raw SQL here — always the repository layer”) — pair with `suggesting-cursor-rules` if it should be always-on; use a **skill** if it is a procedure with steps.

## Workflow

### 1. Name the pattern

Choose a short **slug** (lowercase, hyphens): `verifying-api-before-merge`, `releasing-mobile-build`, etc.

### 2. Draft `SKILL.md`

Create `.cursor/skills/<slug>/SKILL.md` (or in this repo’s pattern, copy from `resources/<slug>/SKILL.md` when contributing upstream).

Frontmatter:

```yaml
---
name: <slug>
description: One line: what it does and when to use it. Ends with a clear trigger.
user-invocable: true   # optional, if the user should be able to invoke by name
---
```

Body sections (keep lean):

1. **Title** — human-readable.
2. **When to use** — bullets.
3. **Steps** — numbered, imperative, tool names where useful (`npm`, `gh`, MCP tools).
4. **Notes** — edge cases, safety, when **not** to use.

Match the tone of other skills in the repo: concrete commands, no filler.

### 3. Validate

- **Description** is specific enough for Cursor to **match** the skill when the user describes the task.
- Steps are **executable** by an agent without guessing repo layout (or say “detect package manager from lockfile”).
- No secrets or machine-specific paths.

### 4. Point the user to it

Tell the user where the file lives and that the agent will pick it up on the next chat in that workspace.

## Relationship to rules and hooks

| Mechanism | Use for |
|----------|---------|
| **Skill** | On-demand procedure, branching steps, tool usage. |
| **Rule** (`.cursor/rules/`) | Always-on conventions, style, file patterns. |
| **Hook** (`.cursor/hooks.json`) | Automate after file save / stop events. |

If the pattern is “every time I save, run X,” suggest a **hook** instead. If it is “when I ask to ship,” keep it as a **skill**.

## Notes

- Prefer **one skill per workflow** — avoid megaskills that try to cover every situation.
- Update an existing skill instead of adding a duplicate if the workflow evolves.

© spencerpauly · CC0-1.0 · spencerpauly/awesome-cursor-skills

Similar skills

All skills for Agent setup: memory, context, orchestration →

From the same set59

saving-workspace-context The skill writes research, decisions and templates into your workspace files, so the next session starts with context instead of a blank slate. CX Codex +1 495installs codebase-onboarding Fires five explore subagents in parallel to cover architecture, data models, APIs, auth and deployment, then merges their findings into one onboarding doc. CX Codex +1 476installs auditing-performance A skill that audits app performance: bundle size, rendering, database queries and Core Web Vitals. Useful when pages load slowly or the UI stutters. CX Codex +1 476installs suggesting-cursor-hooks Watches for repetitive check requests and suggests automating them with Cursor hooks. Useful when you find yourself repeatedly asking the agent to run linters or tests. CX Codex +1 475installs creating-pr A skill that walks the agent through opening a pull request: branch prep, title, structured description, self-review and reviewer requests. CX Codex +1 465installs database-design Designs relational database schemas, foreign keys, indexes, and constraints from raw requirements, with output tailored for SQL, Prisma, or Drizzle. CX Codex +1 462installs parallel-exploring Launches several explore subagents at once so you can map a large codebase fast. Useful for onboarding and for tracing a feature across layers. CX Codex +1 459installs seo-auditing Audits technical SEO in web projects, covering meta tags, structured data, robots.txt, sitemaps, and Core Web Vitals. Useful before shipping pages to production. CX Codex +1 456installs

Project sponsors

Companies that keep this analytics open
Gold sponsor

Impressions, clicks and code copies — open statistics. We keep the numbers public for the same reason NeBlask itself is public. Become a sponsor