agentleFS
ryagi97ryagi97/claude-skills/skill-creator-skill/SKILL.md

skill-creator-skill

Skill0 starsChanged 4 months agoMITView on GitHub

Turn a task you just finished into a small, reliable, single-purpose skill by reverse-engineering the process from the conversation you already had. Also improves or audits an existing skill. Use this AFTER you have done a piece of knowledge work in a chat (research, a draft, an analysis, a prep doc) and want to lock the process in as a skill. Triggers include "build a skill from this", "turn this into a skill", "make a skill out of what we just did", "skill-ify this", "build a skill", "improve this skill", "audit my skill", "why does my skill suck", "make my skill smaller", or when the user finishes a repeatable task and wants to reuse it. Built for knowledge workers, not just engineers. For skills you have NOT done yet (only an idea), hand off to process-interviewer instead.

The file

We split this skill into the rules it gives an agent

3 rules. About 0 are common, 2 are distinctive, and 1 is very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈2

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 1

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Read the situation and pick a branch.

    line 14
  2. Distinctive:

    If unsure, ask one question: "Did we already do this task in this chat, or is it still just an idea?"

    line 22
  3. Very specific:

    Test that it works, then bake in improvement.

    line 52

≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Skill Creator

Most skills are built wrong: someone describes a process from memory before running it, and gets the cleaned-up version that drops the judgment and the exceptions. This does the opposite. You do the task once in a chat, then this turns what actually happened into a small, reliable skill.

Two rules carry the whole skill: keep it modular (one goal, one job) and remember skills are never finished (ship a small working one, then improve it by using it). The reasoning is in references/scope-and-mindset.md.

Route first

Read the situation and pick a branch. Say which branch you picked and why, then proceed.

SituationBranchDo this
The user just finished a real task in this chatBuildSteps 1 to 5 below
The user only has an idea, nothing has been done yetPlanHand off to the process-interviewer skill (interview first, then it builds). Stop here.
The user points at an existing skill to fix or shrinkImproveSkip step 2 (Extract). Run steps 1, 3, 4, 5 against the existing skill.

If unsure, ask one question: "Did we already do this task in this chat, or is it still just an idea?"

The build flow

Track progress out loud:

Task Progress:
- [ ] 1. Scope: one goal, right size, split or not
- [ ] 2. Extract: pull the real process out of the chat
- [ ] 3. Structure: write a small SKILL.md + reference files
- [ ] 4. Prune: cut everything that does not change behavior
- [ ] 5. Eval: test it works, add the self-improvement rule

1. Scope

Decide the one job and whether it should be one skill or several. Read references/scope-and-mindset.md. The cutoff line: a skill is one task doable in a single chat session (roughly 1 to 3 prompts). If the task is bigger, split it into a chain of small skills.

2. Extract

Reverse-engineer what actually happened. Do not ask the user to re-describe their process from memory. Walk back through this conversation and pull out the real steps, the judgment calls, and the reference material. Read references/extract-from-task.md for the technique, then play the process back to the user and let them correct it.

(New to skills, or want the reasoning behind the three build methods? Read references/build-methods.md.)

3. Structure

Write the skill. A SKILL.md does three jobs only: trigger, steps, routing. Everything else goes in reference files. Keep SKILL.md short and small-scoped. Read references/structure.md. If the process needs a live connector or MCP, read references/connectors-and-mcp.md first and decide whether you actually need it. Scaffold the files from templates/_SKILL.md.tmpl and templates/_reference.md.tmpl. (The other two files in templates/ are paste-in content for step 5, not scaffolds.)

4. Prune

Make it as small as possible. Run the deletion test on every paragraph: if removing it would not change what the agent does, remove it. Kill no-ops, duplication, and bloat. Read references/prune.md.

5. Eval

Test that it works, then bake in improvement. Run the functionality eval from references/evals-and-improvement.md (the exact prompt is in templates/eval-prompt.md). Embed the self-improvement rule (templates/self-improvement-rule.md) and the save-good-outputs habit so the skill keeps getting better as it is used.

When you are done

Save the skill as its own folder (SKILL.md plus a references/ folder) in the workspace, show the user the file tree and the SKILL.md, and tell them the one command to trigger it. Then remind them: use it a few times, and let it improve. It is not finished, and that is correct.

Want a worked example before you start? Read references/example-churn-recovery.md.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.