Skill Series Kickoff: From Prompts to Reusable AI Workflows

In the past, many people have used AI by repeatedly copying and pasting the same prompts: asking it to write in a fixed format, organize data, generate reports, check code, output MDX, make PPTs, or rewrite resumes. This can certainly work, but the drawbacks are obvious: you have to re-explain the rules every time, the model can forget the format, and complex processes are hard to reproduce consistently.

The emergence of Skill is aimed at solving this problem.

In simple terms, a Skill can be understood as a "reusable AI workflow playbook." It packages the execution method, formatting requirements, examples, scripts, templates, and resource files for a type of task together, so that when the AI encounters a related task, it can automatically invoke the Skill and complete repetitive work more reliably.

OpenAI defines ChatGPT Skills as reusable, shareable workflows that tell ChatGPT how to complete specific tasks better and more consistently; a Skill may include instructions, examples, and even code.

Anthropic's definition of Claude Skills is very similar: a Skill is usually a folder containing instructions, scripts, and resource files that Claude can dynamically load in appropriate tasks to improve performance in specific scenarios.

From this perspective, a Skill is not merely an "advanced prompt," but a combination of prompts, templates, procedures, and tool resources, distilled into a capability that can be invoked repeatedly.

1. What Exactly Is a Skill?

You can think of a Skill as a combination of three layers:

1. Instruction manual: tells the AI when to use this Skill and what rules must be followed when it does. 2. Templates and examples: provide fixed output formats, reference cases, and style requirements. 3. Scripts and resources: in more advanced scenarios, can include Python scripts, configuration files, brand assets, data processing tools, and more.

If it is a simple task, a Skill might contain only one SKILL.md file. If it is a complex task, a Skill can be a full folder containing:

• my-skill/
• SKILL.md
• scripts/process_data.py
• templates/report_template.md
• references/style_guide.md

The core piece is usually SKILL.md. It typically explains:

• What this Skill does;
• When it should be triggered;
• The steps to execute the task;
• Output format;
• Precautions;
• Which scripts can be called or which files can be referenced.

The OpenAI API documentation also describes a Skill as a file bundle with a SKILL.md manifest that can be used to codify processes and standards. The Codex Agent Skills documentation likewise emphasizes that a Skill is usually a directory containing SKILL.md, and can include scripts, references, and resource files.

2. How Is a Skill Different from a Prompt?

Many people who see Skills for the first time feel it must just be an advanced prompt. That understanding is half-true but incomplete.

A prompt is like a one-time instruction; a Skill is a long-term reusable process asset.

For example, you may input this every time:

Please convert this article to MDX format, keep the original content intact without trimming, fix heading hierarchy, and convert links into clickable format.

This is a prompt.

But if you do this kind of task often, you can convert these rules into an mdx-formatter Skill. Then you only need to say "convert this to MDX," and the AI can execute a fixed process automatically according to the Skill.

OpenAI Cookbook gives a useful positioning for Skills: they can be understood as a "middle layer" between prompts and tools. Prompts define general behavior, tools provide atomic capabilities, and Skills package repeatable processes, instructions, scripts, and resources.

So the value of a Skill is not that a single sentence is written beautifully; it is that it captures experience for a class of tasks and enables the AI to execute more stably each time.

3. Differences Between Skill, Custom GPT, Project, and Tool

To understand quickly, you can distinguish them this way:

For example:

• You ask the AI to "help me polish this article": this is a Prompt.
• You create an "official account article polishing Skill": this is a Skill.
• You create a "GPT dedicated to writing AI articles for me": this is a Custom GPT.
• You keep all site articles, images, and code in one space for long-term maintenance: this is a Project.
• You let the AI call Python to process a spreadsheet automatically: this is a Tool.

The problem a Skill solves best is: the same kind of task repeats, and you want each output to be more consistent.

4. What Does a Typical Skill Look Like?

Here is a minimal Skill example used to prepare Markdown articles for MDX publication.

---
name: mdx-article-formatter
description: Format Markdown articles into clean MDX posts for web publishing. Use this when the user asks to convert, polish, or prepare an article for MDX publication.
---

## MDX Article Formatter

## When to use this skill

Use this skill when the user wants to convert an article into MDX format for publishing on a blog or website.

## Workflow

1. Preserve the original meaning and do not delete important content.
2. Fix heading hierarchy so the article starts with one `#` title and uses `##` / `###` consistently.
3. Convert raw URLs into clickable Markdown links.
4. Fix list formatting, spacing, punctuation, and code block syntax.
5. Ensure the final article is valid MDX.
6. Add a concise introduction and conclusion if the article lacks structure.

## Output rules

- Do not invent unsupported facts.
- Keep the tone clear, natural, and suitable for online publishing.
- Do not overuse bullet points.
- If links are included, preserve them and make them clickable.

This example already shows the core of a Skill:

• name is the Skill name;
• description tells the model when it should be invoked;
• the body specifies concrete workflow and rules;
• output rules help stabilize results.

When writing a real Skill, the description field is crucial. It is more than a summary; it is a key trigger condition for the model to decide "when this Skill should be used." The clearer the description, the lower the chance of missed or false triggers.

5. How to Design a Useful Skill?

It is not recommended to make a Skill overly complex at the start. A practical approach is to begin with tasks you repeat every day and turn the prompts you frequently copy and paste into a fixed process.

1. Clarify the Use Case

First answer one question: what repetitive task does this Skill solve?

For example:

• Convert articles to MDX format;
• Write Xiaohongshu, WeChat official account, or blog posts in a fixed style;
• Generate cover letters from resumes and job descriptions;
• Turn transcription outputs into structured notes;
• Generate weekly reports based on company templates;
• Generate analysis reports from spreadsheets;
• Create PPTs based on brand standards;
• Check projects against coding standards.

A good Skill should solve one clear category of problem, not mix "writing, coding, making PPTs, and data analysis" in one Skill. The more specific the scope, the more stable the effect is usually.

2. Write Clear Trigger Conditions

The clearer the trigger condition, the easier it is for the AI to call it at the right time.

Don’t write this:

This skill helps with writing.

A better version is:

Use this skill when the user asks to polish, restructure, or convert Chinese blog articles into MDX format for publishing on a personal website.

That is, don’t just say "this Skill is useful"; write clearly: what task, what input, what output, what context.

3. Break the Workflow Into Steps

A good Skill is not just "please do a good job," but breaks the task into executable steps.

For example, an article-processing Skill can be split into:

1. Read the original text, identify topic and structure; 2. Fix heading hierarchy; 3. Preserve core content from the original; 4. Add necessary explanations; 5. Convert bare links into Markdown links; 6. Check MDX syntax; 7. Output the final article.

This is much more stable than simply saying "help me improve the article."

4. Add Examples

It is best to add 1–3 examples to the Skill, showing what input and output should roughly look like.

The examples don’t need to be long, but should illustrate the style. For example:

## Example

Input:
Please organize the following AI learning resources into a post:
- https://github.com/datawhalechina/happy-llm
- https://github.com/karpathy/minGPT

Expected output:
- Organize projects by LLM, Agent, and engineering practice modules;
- Each project includes a brief introduction, target audience, and GitHub link;
- Provide a recommended learning order at the end.

The closer the examples are to real usage scenarios, the more usable the Skill becomes.

5. Iterate Continuously

A Skill does not end when you finish writing it once. Treat it like code and maintain it:

• If trigger accuracy is poor, optimize the description;
• If output format keeps being wrong, add more rules;
• If a process repeats often, turn it into a script;
• If reference materials are used frequently, put them in a references folder.

Anthropic’s official materials also emphasize that building a Skill usually includes planning, testing, iteration, distribution, and troubleshooting, rather than just writing a single prompt block.

6. In Which Real-World Cases Is Skill Most Suitable?

Skill is best for tasks that are structured, repetitive, and require stable output.

1. Content Creation

For example:

• MDX article formatting;
• Polishing WeChat official account posts;
• Xiaohongshu title generation;
• SEO title and summary optimization;
• Organizing reference links;
• Unifying Chinese-English translation style.

The focus of these Skills is tone, structure, format, forbidden phrases, and link handling.

2. Office Document Work

For example:

• Writing weekly reports using company templates;
• Turning meeting notes into action items;
• Generating PPT outlines from source material;
• Producing reports based on brand guidelines;
• Organizing customer information into sales briefs.

The focus of these Skills is templates, brand guidelines, fixed sections, and output format.

3. Data Analysis

For example:

• Automatically read CSV files and generate analysis summaries;
• Calculate metrics with fixed definitions;
• Generate visualization charts;
• Output analysis reports;
• Check outliers and missing values.

These Skills can be combined with Python scripts to standardize analysis steps. OpenAI API Skills supports uploading reusable file packages and using them in hosted or local shell environments, which suits scenarios requiring code execution.

4. Programming and Development

For example:

• Write code according to project standards;
• Automatically review PRs;
• Generate unit tests;
• Refactor a specific type of component;
• Troubleshoot issues based on error logs.

Claude Code and OpenAI Codex already provide engineering-oriented capabilities related to Skills. For developers, a Skill can be understood as adding task-specific capability to a coding agent: helping it know which standards a project should follow, what steps to use for troubleshooting, and which scripts or documents to prioritize.

7. How Beginners Can Build Their First Skill

If you are a beginner, do not start by learning complex APIs right away. Begin with the simplest SKILL.md.

You can use this template:

---
name: your-skill-name
description: Use this skill when the user asks to [specific task] for [specific scenario].
---

## Skill Name

## Purpose

This skill helps with ...

## When to use

Use this skill when ...

## Inputs

The user may provide ...

## Workflow

1. First, ...
2. Then, ...
3. Finally, ...

## Output format

The final output should include ...

## Rules

- Do ...
- Do not ...

A practical suggestion: do not aim for an all-in-one Skill at first; make one small and stable Skill.

For example:

• Do not make a "Writing Master Skill";
• You can make a "Chinese Blog Article to MDX Skill";
• Do not make a "Data Analysis Skill";
• You can make a "CSV Sales Data Monthly Report Skill";
• Do not make a "Coding Assistant Skill";
• You can make a "Next.js Project PR Check Skill".

The narrower the scope, the more stable the results.

8. Recommended Learning Path

If you want a systematic understanding of Skills, follow this order.

1. First Understand What a Skill Is

Start by reading introductory materials from OpenAI and Anthropic to build the basic concept. The key point is: a Skill is not a one-off prompt, but a reusable and shareable workflow that can include instructions, examples, and code.

Recommended starting points:

• OpenAI ChatGPT Skills;
• OpenAI Academy: Using skills;
• Anthropic Skills GitHub.

2. Then Look at Skill File Structure

The next step is to focus on how to write SKILL.md, especially description, trigger conditions, workflow, and output rules.

Recommended resources:

• Anthropic Skill Creator;
• OpenAI Skill Creator;
• OpenAI API Skills Guide.

3. Then Learn API and Code Execution Scenarios

If you want to use Skills in agents, automation, data analysis, or code execution, you can continue with OpenAI API and Cookbook.

This stage should focus on three things:

1. How to create and upload a Skill; 2. How to let the model choose the appropriate Skill during tasks; 3. How to combine scripts, resource files, and execution environments.

Recommended reading:

• OpenAI API Skills Guide;
• OpenAI Cookbook: Skills in API;
• OpenAI API Reference: Skills;
• OpenAI Blog: Shell + Skills + Compaction.

4. Finally Study Claude Code and Codex Scenarios

If your focus is AI coding, code assistants, and agent engineering, focus on Claude Code and Codex.

These materials are more suitable for understanding how Skills are used in real engineering practice: for example, project conventions, automated checks, code generation, documentation generation, test workflows, and deployment workflows.

Recommended reading:

• Claude Code Skills;
• Claude Code Overview;
• Claude Code Common Workflows;
• OpenAI Codex Agent Skills.

9. Curated High-Quality GitHub and Documentation Links

Below are skill-learning resources that I think are worth bookmarking.

1. OpenAI: Skills in ChatGPT

Target readers: beginners who want to understand the basic concepts of ChatGPT Skills.

This article is useful for understanding the positioning of Skills: they are not one-time prompts but reusable, shareable workflows that can include instructions, examples, and code.

2. OpenAI Academy: Using skills

Target readers: people who want to understand practical usage scenarios in plain terms.

The OpenAI Academy article is more product-and-practice oriented and helps non-programmers understand why Skills are needed, and how Skills, GPT, and Projects work together.

3. OpenAI API Skills Guide

Target readers: developers and learners of agent engineering.

This is suitable for understanding how to upload, manage, and attach reusable Skills in the API, especially for data analysis, code execution, and automated workflows.

4. OpenAI Cookbook: Skills in API

Target readers: people who want complete code examples.

Its value is that it does not only discuss concepts; it shows how to create, upload, and invoke Skills.

5. OpenAI Codex Agent Skills

Target readers: users of Codex or those focused on AI coding assistants.

Codex Skills are more oriented toward coding and engineering scenarios and can be understood as adding task-specific capabilities to Codex.

6. Anthropic Skills GitHub

Target readers: people who want to see Skill folder structures and real examples.

This is very important for learning Claude Skills, as it shows how instructions, scripts, and resource files can improve model performance in specific tasks.

7. Anthropic Skill Builder Guide

Target readers: people who want to systematically learn Skill design methods.

This PDF is like a pocket handbook, covering Skill basics, planning and design, testing and iteration, distribution and sharing, common patterns, and troubleshooting.

8. Claude Code Skills

Target readers: developers using Claude Code.

This document helps you understand how to expand Claude Code capabilities with Skills and how to distill custom processes into engineered capabilities.

9. openai/skills

Target readers: people who want to see OpenAI Skills examples and systematic Skill writing.

This repository can serve as a reference for naming conventions, directory organization, and SKILL.md style.

10. Simon Willison: OpenAI Skills API Hands-On Demo

Target readers: people who want to read a developer-oriented practical guide.

This is a practical record suitable for developers, showing how to build, compress, upload, and invoke Skills through the OpenAI API.

10. A Copy-and-Use Chinese Writing Skill Example

If you frequently write Chinese technical articles, you can start by adapting this Skill.

---
name: chinese-tech-blog-writer
description: Use this skill when the user asks to write, polish, restructure, or prepare a Chinese technology blog post for online publishing. This skill is especially useful for AI, programming, GitHub project introductions, tutorials, and tool reviews.
---

## Chinese Tech Blog Writer

## Purpose

Help the user turn rough notes, links, screenshots, or fragmented ideas into a clear Chinese technology article suitable for online publishing.

## Workflow

1. Identify the article topic and target readers.
2. Preserve the user's original meaning and important links.
3. Organize the article with a clear title, introduction, sections, and conclusion.
4. Explain technical terms in plain Chinese.
5. Add concise project introductions when GitHub links are provided.
6. Convert raw URLs into clickable Markdown links.
7. Avoid exaggerated claims and unsupported facts.
8. Make the tone natural, practical, and suitable for public publishing.

## Output format

- Use Markdown or MDX-compatible syntax.
- Use `#` for the main title.
- Use `##` for major sections.
- Use tables only when they improve readability.
- Keep paragraphs readable and not too fragmented.

## Rules

- Do not delete the user's original important content.
- Do not fabricate project features.
- If online sources are used, include reference links.
- If a claim is uncertain, write it cautiously.

This Skill is suitable for handling:

• GitHub project recommendation articles;
• AI tools tutorials;
• Technical learning paths;
• Personal website articles;
• MDX blog content.

11. Common Mistakes in Writing Skills

1. Scope Is Too Broad

Many people start by creating an "all-in-one writing Skill," trying to cover everything, and in the end nothing is stable.

A better approach is to split into multiple small Skills:

• mdx-formatter
• github-project-intro-writer
• resume-polisher
• ai-tool-review-writer
• data-report-generator

2. description Is Too Vague

description should not just say "help writing" or "increase efficiency." It should clearly tell the model: when to use it, what input to handle, and what output to produce.

3. Only Requirements, No Workflow

A poor Skill only writes:

Write it more professionally.

A good Skill writes:

First identify the target audience, then organize the structure, then add background explanation, and finally check links and formatting.

4. No Testing

After writing a Skill, it is best to test it with 3–5 real tasks:

• Can it trigger correctly?
• Is the output format stable?
• Are links missing?
• Does it randomly delete content?
• Does it fabricate information that does not exist?

Modify the Skill iteratively after testing.

12. My Understanding: Skills as the Start of AI Workflow Assetization

In the past, we often relied on temporary prompts when using AI. But prompts have the biggest drawbacks: they are hard to manage, hard to reuse, and hard to scale across teams. The value of Skills lies in the fact that they distill your experience, processes, templates, and tools into repeatable capability.

For individuals, Skills can reduce how many repetitive prompts you need to write. For teams, Skills can standardize output expectations. For developers, Skills can become modular capabilities within an agent system. For content creators, Skills can encode writing style, article structure, and publishing standards.

Therefore, a Skill is not just a simple new feature, but a new way of working:

Upgrade one-time prompts into reusable workflows, and turn personal experience into capabilities the AI can reliably invoke.

If you ask AI to do the same type of task repeatedly, you are a good candidate for creating your own Skills.

This series also includes concrete examples, such as “Skill Example: Add a Complete Workflow to a Coding Agent with Superpowers”, which can help you see how Skills apply in real engineering.

FAQ

What is the difference between Skill and a Prompt?

A prompt is like a one-time instruction that needs rules re-explained each time. A Skill is like a reusable process asset that packages instructions, templates, workflows, scripts, and resources, allowing AI to automatically call it in related tasks for more stable reproduction of complex workflows.

How is Skill different from Custom GPT, Project, and Tool?

A Skill encapsulates a fixed process into a reusable capability. A Custom GPT is a dedicated chat assistant for a specific purpose. A Project provides a long-term workspace and context. A Tool enables the AI to call external capabilities or perform actions. You can think of Skill as the "middle layer" between prompts and tools.

What must a Skill contain?

The most central element is SKILL.md, which explains what the Skill does, when it should trigger (description is crucial), execution steps, and output rules. More complex tasks can add scripts/, templates/, references/, and other directories.

How can a beginner write their first Skill?

Start from a task you repeat every day, then write a small, specific SKILL.md first (for example, "Chinese blog article to MDX" instead of "writing master"). Clearly state trigger conditions, inputs/outputs, and workflow steps, then test with 3–5 real tasks and keep iterating.

Reference Sources

• OpenAI Help: Skills in ChatGPT
• OpenAI Academy: Using skills
• OpenAI API Docs: Skills
• OpenAI Cookbook: Skills in API
• OpenAI API Reference: Skills
• OpenAI Blog: Shell + Skills + Compaction
• OpenAI Codex: Agent Skills
• GitHub: openai/skills
• GitHub: openai/openai-cookbook
• GitHub: anthropics/skills
• Anthropic Skill Creator
• Anthropic: The Complete Guide to Building Skills for Claude
• Anthropic Docs: Claude Code Skills
• Anthropic Docs: Claude Code Overview
• Anthropic Docs: Claude Code Common Workflows
• Anthropic Docs: Claude Tool Use Overview
• Simon Willison: OpenAI Skills API Hands-On Demo