Skills & Workflows

What Are Skills and Workflows?

Throughout this course, you have learned how to give AI agents instructions through prompts and configuration files. Skills and workflows take this one step further. They are standardized, repeatable sets of instructions that produce consistent results every time they run.

Think of a skill like a recipe. When you follow a recipe, you get the same dish every time: the same ingredients, the same steps, the same result. Without a recipe, you are improvising. Sometimes the result is great, sometimes it is not, and it is hard to repeat a success.

Skills work the same way for AI agents. Instead of giving the AI a vague instruction like “write me a blog post,” a skill provides a complete, structured set of instructions: what to write, how to format it, what sections to include, what tone to use, and what to check before finishing. The result is predictable and consistent.

A workflow is simply a skill that involves multiple steps in sequence. For example, a blog writing workflow might include: research the topic, create an outline, write the draft, add a call to action, and format for publishing. Each step feeds into the next, and the entire process runs the same way every time.

Why Skills Matter

Skills solve three fundamental problems with AI agents:

1. Consistency

Without a skill, the same prompt can produce wildly different outputs depending on the day, the model version, or even random variation in the AI’s response. One day you get a 200-word summary, the next you get a 500-word essay. Skills eliminate this randomness by specifying exact requirements.

2. Quality

When you invest time writing a detailed skill with clear instructions, quality checks, and formatting rules, you get better output than you would from an improvised prompt. The skill encodes your best thinking about how the task should be done.

3. Shareability

Once you write a skill that works well, you can share it with colleagues, friends, or classmates. They can use the same skill with their own AI agent and get similar results. This makes skills a form of reusable knowledge that can be distributed across teams and communities.

Anatomy of a Skill File

A skill file is a structured document (usually a Markdown file) that defines everything the AI needs to do the task. While the exact format varies by platform, most skills contain these core elements:

Title

A clear, descriptive name for the skill.

Description

A one-or-two sentence explanation of what the skill does. This helps you (and others) quickly understand the skill’s purpose.

Instructions

The detailed, step-by-step instructions the AI should follow. This is the heart of the skill. It includes:

• What the AI should do at each step
• What format the output should use
• What rules and constraints apply
• What to check before marking the task complete

Example (optional but recommended)

A sample input and the expected output. This gives the AI a concrete reference for what “correct” looks like.

Here is what a complete skill file looks like:

# Skill: Weekly Report Summary

## Description
Summarize a weekly status report into a concise executive brief
for senior leadership.

## Instructions
When given a weekly status report, follow these steps:

1. Read the entire report carefully.
2. Identify the top 3 accomplishments from the past week.
3. Identify any blockers or risks.
4. Note the top priorities for the coming week.
5. Write a summary that is exactly 5 sections:
   - **Headline**: A one-sentence summary of the week.
   - **Key Wins**: 3 bullet points, one sentence each.
   - **Risks & Blockers**: 1-3 bullet points. If none, write
     "No blockers this week."
   - **Next Week Priorities**: 3 bullet points, one sentence each.
   - **Action Items**: A numbered list of specific tasks with
     owners and deadlines.

## Rules
- Keep the total summary under 200 words.
- Use plain language. No jargon or acronyms without explanation.
- Do not editorialize or add opinions. Stick to the facts in
  the report.
- Bold all names and deadlines.

## Example Output
**Headline:** The team completed the new onboarding flow and
resolved the payment bug ahead of schedule.

**Key Wins:**
- Launched the redesigned onboarding flow for new users.
- Fixed the payment processing bug affecting 12% of transactions.
- Completed user interviews for the Q2 roadmap.

**Risks & Blockers:**
- Waiting on legal review for the new terms of service.
  Expected by Friday.

**Next Week Priorities:**
- Begin development of the notification system.
- Finalize Q2 roadmap based on user interview data.
- Conduct performance testing on the new onboarding flow.

**Action Items:**
1. **Maria** — Send final onboarding flow metrics to leadership
   by Tuesday.
2. **Carlos** — Follow up with legal on terms of service review
   by Wednesday.
3. **Ana** — Schedule performance testing sessions by Thursday.

This skill file gives the AI everything it needs to produce a consistent, high-quality executive summary every single time.

Skills Across Platforms

Each platform has its own way of implementing skills and workflows. Here is how to create and use them on each platform we cover in this course.

Claude

Claude Code Skills

Claude Code supports skills as Markdown files stored in your project.

How to create a skill:

1. Create a .claude/skills/ folder in your project.
2. Add a Markdown file for each skill (e.g., weekly-report.md).
3. Write your skill instructions in the file using the anatomy described above.
4. When you want to use the skill, tell Claude: “Use the weekly report skill to summarize this document.”

Claude Projects also support skills through the project’s instructions and knowledge base. You can upload reference documents and set instructions that act as persistent skills for every conversation in that project.

Skills in Claude Code are read from the file system, so they persist across sessions and can be version-controlled alongside your project files.

ChatGPT

Custom Instructions and Custom GPTs

ChatGPT implements skills through Custom Instructions (available on all plans, including free) and Custom GPTs (requires a paid plan: Plus, Team, or Enterprise).

Using Custom Instructions (free):

1. Go to chatgpt.com and click your profile icon.
2. Go to Settings > Personalization > Custom Instructions.
3. Enter your skill instructions in the provided fields.
4. These instructions apply to all new conversations.

Creating a Custom GPT (requires paid plan):

1. Click Explore GPTs in the sidebar.
2. Click Create to make a new GPT.
3. In the Configure tab, enter your skill instructions in the Instructions field.
4. Give it a name, description, and optionally upload reference files in the Knowledge section.
5. Save and publish (you can keep it private or share it).

Each Custom GPT is essentially a skill packaged as a standalone assistant. Custom GPTs can also be shared publicly in the GPT Store.

Free users can also paste skill instructions at the start of each conversation, or browse and use existing GPTs from the GPT Store.

Gemini

Gemini Gems

Google Gemini uses Gems as its skill system. Creating Gems requires Gemini Advanced (paid plan).

How to create a Gem (requires Gemini Advanced):

1. Go to gemini.google.com.
2. Click Gem manager in the left sidebar.
3. Click New Gem.
4. Enter your skill instructions in the Instructions field.
5. Give the Gem a name and description.
6. Save your Gem.

When you want to use the skill, start a conversation with your Gem. It will follow the instructions you set, producing consistent output for that specific task.

Gems are tied to your Google account and can be accessed from any device where you use Gemini.

Free users: Paste your skill instructions at the start of each conversation to achieve similar results.

Ollama

Custom Models via Modelfile

Ollama implements skills through custom models defined in Modelfiles.

How to create a skill:

1. Create a Modelfile with a descriptive SYSTEM prompt that encodes your skill instructions.
2. Build the model:

   ollama create report-summarizer -f Modelfile

3. Run the model whenever you need that skill:

   ollama run report-summarizer

Each custom model is essentially a skill. You can have multiple Modelfiles for different tasks: report-summarizer, email-writer, content-creator, etc.

Example Modelfile for a skill:

FROM llama3

SYSTEM """
You are a weekly report summarizer. When given a status report,
always produce output in exactly this format:

1. Headline (one sentence)
2. Key Wins (3 bullet points)
3. Risks & Blockers (1-3 bullet points, or "None")
4. Next Week Priorities (3 bullet points)
5. Action Items (numbered list with names and deadlines in bold)

Keep the total output under 200 words. Use plain language.
Do not add opinions.
"""

LM Studio

System Prompt Presets as Skills

LM Studio uses system prompt presets as its skill mechanism.

How to create a skill:

1. Open LM Studio and load your preferred model.
2. In the Chat tab, write your skill instructions in the System Prompt field.
3. Save this configuration as a preset with a descriptive name (e.g., “Weekly Report Summarizer”).
4. When you need to use the skill, load the preset before starting your conversation.

You can maintain a library of presets for different tasks. Switching between skills is as simple as loading a different preset.

Since LM Studio runs locally, your skill presets stay on your computer and can be backed up like any other file.

Example: A Skill That Always Formats Output the Same Way

Let’s build a practical skill that demonstrates the power of consistent formatting. This skill takes any unstructured meeting notes and converts them into a standard format.

# Skill: Meeting Notes Formatter

## Description
Transform raw meeting notes into a clean, standardized format
suitable for sharing with the team.

## Instructions
When given unstructured meeting notes, produce output in
exactly this format:

### Meeting Summary
**Date:** [extract from notes or write "Not specified"]
**Attendees:** [list names found in notes, comma-separated]
**Duration:** [extract from notes or write "Not specified"]

### Key Discussion Points
- [Bullet point for each major topic discussed, one sentence each]

### Decisions Made
- [Bullet point for each decision, stating what was decided]
- If no decisions were made, write: "No formal decisions
  were recorded."

### Action Items
| # | Task | Owner | Deadline |
|---|------|-------|----------|
| 1 | [task] | [name] | [date] |

If no deadlines were mentioned, write "TBD" in the
deadline column.

### Next Meeting
[Date and time if mentioned, otherwise "To be scheduled"]

## Rules
- Do not add information that is not in the original notes.
- If something is unclear, mark it with "[unclear]" rather
  than guessing.
- Keep each bullet point to one sentence.
- Always include all five sections, even if some are empty.

Without this skill, every time you ask an AI to format meeting notes, you get a different structure. With this skill, you get the exact same format every time. Your team knows where to find the action items, the decisions, and the next steps. This consistency saves everyone time and reduces miscommunication.

Building Your First Skill: A Step-by-Step Approach

Here is a practical process for building any skill from scratch.

Step 1: Define the purpose

Write a clear one-line description of what the skill does and when to use it.

“Turns a rough project idea into a structured one-page proposal with goals, timeline, budget estimate, and next steps.”

Step 2: Write the initial instructions

Start with the basics: what steps should the AI follow, what sections should the output include, and what rules apply.

Step 3: Test with different inputs

Try the skill with at least five different inputs. Use easy ones and hard ones. Note where the output is inconsistent, missing information, or poorly formatted.

Step 4: Refine based on results

After each test, add rules to handle edge cases. Did the AI add information that was not in the input? Add a rule: “Do not add information not present in the source material.” Did it use an inconsistent format? Tighten the format instructions.

Step 5: Save and reuse

Save the final version in your platform’s skill format. Give it a clear, descriptive name so you can find it later.

Tip

Start with a simple skill and improve it over time. A basic skill you actually use every day is far more valuable than an elaborate one you never finish writing. The self-modifying prompt pattern from earlier in this course works perfectly here: use the skill, note what went wrong, add a rule, and repeat.

Why Skills Are Worth the Investment

Creating a skill takes more upfront effort than writing a quick prompt. But that effort pays for itself many times over:

• You write the instructions once and use them dozens or hundreds of times.
• Quality improves because you can refine the skill based on feedback, making each iteration better than the last.
• Onboarding becomes easier because you can hand new team members a set of skills instead of explaining your processes verbally.
• Output becomes predictable, which means you can build processes and workflows around AI output with confidence.

Note

Skills and the self-modifying prompts technique from earlier in this course work beautifully together. Start with a basic skill, use it several times, and each time you spot an issue, add a new rule to the skill. Over time, the skill becomes increasingly refined and reliable.

Key Takeaways

• Skills are standardized, repeatable sets of instructions that produce consistent AI output. Workflows are multi-step skills.
• A skill file contains a title, description, detailed instructions, rules, and optionally an example.
• Every major platform supports skills in some form: Claude Code skills, ChatGPT Custom Instructions or Custom GPTs (paid), Gemini Gems (paid), Ollama Modelfiles, and LM Studio presets.
• Skills solve three problems: inconsistency (different output every time), quality (mediocre results from vague prompts), and shareability (hard to distribute knowledge).
• The upfront investment in creating a skill pays for itself quickly through reuse, consistency, and quality.
• Start simple, test thoroughly, and refine over time using the self-modifying prompt pattern.