How to Make an AI Skill: Instructions You Can Reuse

An AI skill is a saved, named instruction for a task you repeat: drafting a certain kind of email, summarizing meeting notes in a consistent format, reviewing a document against a checklist or generating a status update from task notes. Writing a skill once and reusing it saves setup time and keeps outputs consistent across sessions and models.

Any task you find yourself prompting from memory more than once a week is worth turning into a skill. Tools like fenbs store approved skill instructions in a shared library that connected AI apps can read before starting work, so you do not have to paste the same prompt into every new chat.

What makes a task worth turning into a skill

Not every task needs a skill. A skill pays off when the task repeats, when the output format matters, or when you want the same result regardless of which AI app or chat session you use. A one-off request for a specific piece of analysis is better handled as a direct prompt.

Good candidates for skills are tasks where you already have a mental template: you know what a good result looks like and you can describe the steps to get there. Bad candidates are tasks that change significantly each time or where the best approach is still unclear.

Step 1: describe the task in plain language

Start by writing out what the task involves, as if explaining it to a capable colleague who has never done it before. Include the input, the steps and the output. Do not worry about prompt formatting yet; just capture what the task actually is.

Say a three-person design studio reviews client feedback every Friday. Their plain-language description might be: "Read the client's feedback email. Group the feedback into visual, functional and content comments. For each group, write a one-sentence summary and list the specific items. Flag anything that contradicts a previous decision."

Step 2: add the input and output specification

A plain-language description becomes a working skill when you add two specifics: what the AI receives and what it returns. Name the input type ("a client feedback email in plain text") and the exact output format ("three sections labeled Visual, Functional and Content, each with a one-sentence summary followed by a bulleted list").

Add the edge cases you know exist. "If a comment could fit in two categories, put it in the more specific one." "If no feedback is present for a category, include the section heading and write none." Explicit edge cases prevent the AI from guessing and producing a different structure each time.

Step 3: test on real inputs

Run the skill on at least three real examples from your work. Pick a straightforward one, a short or sparse one, and one with a complication you know exists. Compare each output to what you would have produced yourself.

Make a note of every place the output is wrong or off. Then look for the underlying cause: was it missing from the instruction, or was the instruction ambiguous? Add one clarifying sentence for each failure and test again. Two or three rounds of this usually produces a skill that handles most real inputs well.

Step 4: record what you learned

After testing, write down what you changed and why. "Added 'if no feedback for a category, include the heading and write none' because the AI was omitting sections when feedback was thin." These notes are the lessons that make the skill reliable over time and help you adapt it when you move to a new AI tool.

Lessons also help when the skill stops working. AI apps update, and a skill that worked well six months ago may behave differently today. A record of what the skill is supposed to do and what problems it solved makes it much faster to diagnose and fix.

For more on AI tools you might adapt a skill for, see what is Cursor AI and how to use AI at work. For broader context on what AI skills are and how different apps implement them, what is an AI brain explains the bigger picture.

Step 5: adapt the skill for different AI tools

A well-written skill in natural language works in any AI app. The core instruction stays the same; only the delivery mechanism changes. In ChatGPT you might paste it into custom instructions. In Claude you might add it to a Project. In Cursor or another coding tool you might keep it in a project file.

Keep one master copy of each skill in plain language. When you adapt it for a specific app, treat that version as a copy, not the original. If you improve the skill after testing it in one app, update the master copy and then refresh the app-specific versions.

How to do this with fenbs

fenbs keeps your approved skill instructions in a shared library alongside your project context. Connected AI apps can list available skills and load any one by name before starting work.

1. Create a free account. Set up a project for the work these skills belong to.
2. Add each approved skill to the Skills and prompts section. Include the plain-language instruction, the input and output specification, and a short note on what the skill is for.
3. Record test results as lessons in the project. When a skill produced the wrong result, note what it missed and what you added.
4. Connect your AI app over MCP at Integrations. The app can list your skills, read the full instruction and load relevant lessons before starting a task.
5. When you improve a skill after a bad result, update it in fenbs. Every connected app gets the new version the next time it loads the skill.