Open WebUI Skills: Create Workflows Without Code

Open WebUI Skills let you attach reusable instructions to your AI models, automating workflows without writing code. Unlike System Prompts, which shape how a model behaves, Skills are structured documents that tell models exactly what to do in specific scenarios--from code reviews to compliance checks. They live inside Open WebUI and execute on every conversation where you enable them.

What Are Open WebUI Skills?

Skills are plain-text instructions (usually in Markdown format) that models follow during a conversation. They're not code. They're workflows. Think of a Skill as a detailed checklist or template that a model uses to structure its responses. When you invoke a Skill, the model reads it as context and follows its logic.

Open WebUI comes with three architectural layers: System Prompts (which define the model's personality), Skills (which define specific workflows), and MCP Tools (which give models the ability to call external functions). Most teams use all three, each for different purposes.

A Skill is typically written in plain language with examples. You might have a "Code Review Checklist" Skill that tells the model to check for security issues, performance bottlenecks, and style violations before responding to code review requests. Or a "Customer Troubleshooting" Skill that walks the model through a diagnostic tree. The model reads the Skill, understands its intent, and applies it to the current conversation.

Skills are stored in your Open WebUI workspace. You can create them from scratch, import them from Markdown files, or adapt them from existing examples. Once created, you attach them to models, organize them into folders, and control who can see them. Some Skills apply to every conversation with a model (lazy-loaded). Others activate only when you explicitly mention them with a $ prefix, or when you toggle them on for a specific chat.

Skills vs. System Prompts vs. MCP Tools: When to Use Each

These three layers often confuse teams because they all shape model behavior. Here's the clearest distinction:

System Prompts tell the model who it is and how it should behave. Example: "You are a helpful code reviewer. Always prioritize security and performance." System Prompts set tone and guardrails. They apply to every response from the model.

Skills tell the model what workflows to run for specific tasks. Example: "Here is a checklist for code reviews. First, check for SQL injections. Second, check for null pointer errors. Third, check for inefficient loops. Return results in this format." Skills are procedural. They apply when you invoke them.

MCP Tools (Model Context Protocol) give the model the ability to call external functions or systems. Example: "When asked to send an email, call the email service API." Tools are executable. They let the model take actions outside the conversation.

A real scenario: You're building a support bot. System Prompt shapes its personality: "You are friendly, patient, knowledgeable support staff." Skill defines the workflow: "Follow this troubleshooting tree: first ask about OS, then check for updates, then collect error logs." Tool gives it power: "When the user says 'escalate,' call the ticketing API to create a ticket."

You can run all three simultaneously. A single model can have a System Prompt defining its role, five Skills defining different workflows (code review, troubleshooting, refund approval, etc.), and three MCP Tools giving it access to external systems.

Three Ways to Invoke Skills in Open WebUI

Open WebUI gives you three ways to activate a Skill:

1. Mention Invocation ($skillname) Type $code-review at any point in your conversation. The model loads that Skill for that single message. This is useful when you want a Skill for one specific task but not the whole conversation. For example, you might ask a question normally, then add $summarize at the end to invoke a summarization Skill just for that response.

2. Per-Chat Toggle Open the chat sidebar, find the Skill section, and click the toggle next to any Skill. It activates for the entire conversation. Switch chats, and the toggle resets--the Skill only applies to that specific conversation. This is how you'd handle a longer workflow, like drafting a document where you want a "Writing Style" Skill active for every response in that chat.

3. Model-Attached (Lazy-Loaded) Go to Workspace > Models, select your model, and attach Skills to it. Those Skills load automatically in every new chat with that model, without you having to do anything. This is lazy-loaded context--Open WebUI includes the Skill text in the model's context window only when needed, keeping overhead low. Use this for Skills that apply universally (like company compliance guidelines or standard operating procedures).

Creating Your First Skill

Let's build a "Code Review Checklist" Skill from scratch.

Open Workspace > Skills > Create New Skill. You'll see a text editor. Paste this template:

# Code Review Checklist

You are reviewing code. Follow this checklist for every code review:

## Security
- Check for SQL injection vulnerabilities
- Verify authentication/authorization logic
- Look for hardcoded secrets or credentials

## Performance
- Identify N+1 query problems
- Check for inefficient loops
- Look for missing indexes

## Style & Maintainability
- Verify naming conventions match the project
- Check for complex functions that should be split
- Confirm comments explain why, not what

## Output Format
Provide your review in this format:
1. Security issues found: [list]
2. Performance issues found: [list]
3. Style issues found: [list]
4. Overall recommendation: [approve / request changes]

Save it. Name it "code-review" and set the description to "Systematic code review with security, performance, and style checks."

Now you have a Skill. To use it:

Import from file: If you have Skills as Markdown files from another source (GitHub, a shared folder), go to Workspace > Skills > Import. Upload the .md file. Open WebUI parses it and creates the Skill.

Export for backup: Click the three-dot menu on any Skill and choose Export. It downloads as a .md file. Store it in version control so your team can access it across deployments.

Share with your team: Open the Skill, check the Access Control section, and set permissions. You can make it visible to all users, specific teams, or keep it private.

Binding Skills to Models

Once you've created Skills, attach them to your models so they activate automatically.

1. Go to Workspace > Models
2. Click on the model you want to configure (e.g., "GPT-4 via API")
3. Scroll to the Skills section
4. Click "Add Skill" and select from your library
5. If you have many Skills, they'll appear in a dropdown. Choose the ones you want attached
6. Save

When you start a new chat with that model, the attached Skills load into context automatically. The model sees them as part of its instructions and follows them.

Lazy-loading behavior: Open WebUI doesn't include every Skill in every context window. It loads only the Skills you've activated for that chat or that message. This keeps your context window efficient--a 10,000-token Skill doesn't consume 10,000 tokens if you're not using it.

Access control: Skills can be restricted by user, team, or organization role. If you're an admin, you control who sees which Skills. If someone tries to use a Skill they don't have access to, Open WebUI blocks it. This is essential for compliance--you can lock compliance-related Skills to specific teams.

Lazy loading failures: On rare occasions, lazy loading fails if the model's context window is full or if the Skill file is corrupted. If a Skill doesn't activate, check the Workspace > Skills panel for error messages. Most failures are resolved by clearing the chat history or re-saving the Skill.

Common Use Cases for Skills

Code Review Standards Attach a "Code Review" Skill to your developer chat. Every time someone pastes code and asks "review this," the model follows your checklist: security checks, performance analysis, style consistency. You get consistent, thorough reviews without repeating instructions every time.

Writing Style Guides Many teams have house styles. A "Technical Writing" Skill can encode your guidelines: tone, terminology, structure. When you're drafting documentation, toggle the Skill and the model applies your style consistently. No more "does this sound like our brand?" iterations.

Troubleshooting Playbooks Build a "Customer Troubleshooting" Skill that walks the model through a decision tree. When a customer reports an issue, the model asks the right diagnostic questions in the right order, gathering data efficiently. This scales your support team's knowledge without hiring more people.

Tool Usage Instructions If you use specific tools internally (Notion, Slack integrations, custom dashboards), encode a Skill that teaches the model how to guide users through those tools. "Notion Onboarding" Skill teaches the model to help new employees set up their workspace. "Slack Automation" Skill teaches it to guide teams through bot setup.

Compliance and Audit Financial services and healthcare teams use Skills to enforce audit trails and compliance rules. A "HIPAA Compliance" Skill ensures that the model never suggests workflows that violate privacy regulations. It runs on every conversation, keeping your team safe.

Limitations and Best Practices

Skills are plain-text only. They don't execute code or call APIs themselves. They're instructions the model reads and follows. If you need the model to actually send an email or update a database, you need an MCP Tool, not a Skill.

Context window impact. Large Skills consume tokens. A 5,000-token Skill plus a 2,000-token conversation uses 7,000 tokens of your context window. If you're on a model with an 8,000-token limit, you've only got 1,000 tokens left for responses. Design Skills to be concise. Use lazy-loading to minimize impact.

Execution time. There's no execution time guarantee. If a Skill is complex, the model takes longer to "think through" it. A 100-step checklist might take a few seconds longer per response than a 5-step checklist. Monitor performance in production and simplify as needed.

Function calling requirement. Skills work best with models that support function calling (most modern LLMs do). Some older or smaller models don't parse structured instructions as reliably. Test your Skills with your specific model before deploying them to your team.

No skill versioning built-in. If you update a Skill, all chats using that model get the new version immediately. If the update breaks something, there's no automatic rollback. Keep exports in version control. Use naming conventions like "code-review-v1" if you need to maintain multiple versions.

When lazy loading fails. If a Skill doesn't activate, check: Is the model's context window full? Is the Skill file corrupted? Does the user have permission to access it? Most failures are permission or context issues, not Skill bugs.

Best practices:

• Store Skill files in Git alongside your documentation
• Name Skills descriptively: "code-review" not "skill1"
• Write Skills in plain English with examples
• Test Skills with your intended model before rolling out to users
• Periodically review and archive unused Skills
• Document what each Skill does in your workspace notes

Frequently Asked Questions

What are skills in Open WebUI? Skills are plain-text instructions (usually Markdown) that models follow during conversations. They're reusable workflows that automate tasks like code reviews, troubleshooting, or compliance checks without requiring code.

How do you use skills in Open WebUI? You can invoke Skills three ways: mention them with $ (e.g., $code-review), toggle them on for a specific chat, or attach them to a model so they load automatically. Attachment is the most common for workflows you run regularly.

What's the difference between Skills and System Prompts? System Prompts define how a model behaves (its personality and role). Skills define specific workflows the model runs. You typically use both: a System Prompt shapes tone, Skills shape procedures.

Can you use Skills with any model? Skills work best with models that support function calling (most modern LLMs). Some older models may not parse Skills as reliably. Test with your specific model first.

Do Skills consume tokens? Yes. Skill text is included in the model's context. A large Skill (5,000+ tokens) will reduce how many tokens you have available for conversations. Use lazy-loading to minimize impact.

How do you share Skills with your team? Export Skills as Markdown files and store them in Git or a shared folder. Import them into other Open WebUI instances. Use access control in Workspace > Skills to restrict visibility by user or team.

What happens if a Skill is too large? If a Skill exceeds your model's context window, it will consume most of your available tokens, leaving little room for conversation. Keep Skills concise and use lazy-loading to manage size.

The Bottom Line

Open WebUI Skills let you automate workflows without code. They're straightforward to create, easy to version, and powerful in teams. The hard part isn't building Skills--it's choosing when to use them versus when a System Prompt or MCP Tool is a better fit.

Skills shine when your models run on stable, optimized infrastructure. Opsily's managed Open WebUI hosting handles the setup, scaling, and maintenance--so your team focuses on building great Skills, not managing servers.