Benai skill creator skill
Skill naveedharri/benai-skills/plugins/meta/skills/benai-skill-creator-skill
npx -y skills add naveedharri/benai-skills --skill benai-skill-creator-skillAssembled from the repository path, not quoted from the project. Check it against their README if it does not work.
What its author says it does
Copied from the file, not written here
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.
SKILL.md
4.5 KB, as published. Nobody here has run it
BenAI 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.
| Situation | Branch | Do this |
|---|---|---|
| The user just finished a real task in this chat | Build | Steps 1 to 5 below |
| The user only has an idea, nothing has been done yet | Plan | Hand off to the process-interviewer skill (interview first, then it builds). Stop here. |
| The user points at an existing skill to fix or shrink | Improve | Skip 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.