How to Build a Custom AI Skill

You have a task you repeat weekly. It takes 15 minutes each time. A custom Skill can reduce it to 2 minutes. Here is how to build one from scratch.

Step 1: Define the Task

Before building, answer these questions:

• What is the input? (clipboard text, a file path, a topic, nothing)
• What should the AI do? (read, search, analyze, generate, execute)
• What is the output? (clipboard text, a file, terminal output, an app action)
• Which tools are needed? (Bash, File Read, Clipboard, Web Search, Screenshot, etc.)

Write this down as a one-sentence description: “This skill reads my clipboard email, drafts a reply in my voice, and puts it back in my clipboard.”

Step 2: Write the System Prompt

The system prompt is the core of any skill. It is the instructions the AI follows every time the skill is invoked. Good system prompts are:

Specific: “Fix grammar errors” instead of “improve the text” Structured: Number the steps the AI should follow Bounded: Define what the skill should NOT do Format-aware: Specify the output format

Template

You are a [role]. When invoked:
1. [First action - e.g., "Read the user's clipboard content"]
2. [Processing step - e.g., "Analyze the text for grammar, spelling, and clarity issues"]
3. [Output step - e.g., "Write the corrected version to the clipboard"]

Rules:
- [Constraint 1 - e.g., "Do not change the meaning or tone"]
- [Constraint 2 - e.g., "If the text is already correct, say so instead of making unnecessary changes"]

Output format: [e.g., "Clean text ready to paste, no explanations or commentary"]

Step 3: Choose Tools

Only enable the tools the skill actually needs:

Tool	When to Enable
Clipboard Read	Skill processes clipboard content
Clipboard Write	Skill outputs to clipboard
File Read	Skill reads files from disk
File Write	Skill creates or modifies files
File Edit	Skill edits specific parts of files
Bash	Skill runs terminal commands
Screenshot	Skill analyzes UI, charts, or visual context
Grep	Skill searches file contents
Glob	Skill finds files by name
List	Skill browses directories
Screenshot	Skill analyzes screen content
Web Search	Skill needs current web info
Web Fetch	Skill reads web page content

Fewer tools = more focused skill. A writing skill does not need Bash. A code review skill does not need Web Search.

Step 4: Choose a Model (Optional)

You can lock a skill to a specific model or leave it flexible:

• Lock to a cheap model for simple, repetitive tasks (save money)
• Lock to a premium model for tasks requiring high-quality reasoning
• Leave flexible if you want to choose the model each time

Example: A grammar check skill works fine with a cheap model. A complex code analysis skill benefits from Claude or GPT.

Step 5: Create the Skill

1. Open Chapeta settings
2. Go to Skills
3. Click “Create Skill”
4. Enter the name, system prompt, tools, and optional model
5. Save

Step 6: Test and Iterate

Run your skill 5-10 times with different inputs. Look for:

• Missed cases: Does it handle edge cases? Empty input? Very long input?
• Wrong behavior: Does it do things the system prompt did not intend?
• Output quality: Is the format consistent?

Adjust the system prompt based on what you observe. This is the most important step. Good skills are not written once; they are refined.

Common Refinements

“The AI adds unnecessary commentary” -> Add: “Output only the result. No explanations, no preamble.”

“The output format varies” -> Add explicit format instructions: “Always use markdown headers. Always use bullet lists.”

“The AI does too much” -> Add constraints: “Only fix grammar. Do not rewrite sentences. Do not add content.”

“The AI misses context” -> Add context in the prompt: “The user is a software developer. Technical terms should be preserved.”

Step 7: Build a Habit

The skill only saves time if you use it. Tips:

• Use descriptive names you will remember
• Start each day by reviewing which skills apply to today’s tasks
• Replace the manual workflow immediately; do not keep the old habit “just in case”

Real Example: Blog Post Outline

Let me walk through a complete example:

Task: Given a topic, create a structured blog post outline.

Name: Blog Outline
System Prompt: Given a blog topic from the user, create a structured outline:
1. Title (compelling, under 60 characters for SEO)
2. Introduction hook (2-3 sentences)
3. Main sections (4-6 sections with ## headers)
4. Key points under each section (3-4 bullet points)
5. Conclusion direction
6. Suggested keywords (5-8 for SEO)

Rules:
- Target 800-1200 word final post length
- Include one data point or statistic suggestion per section
- End with a clear call to action direction

Output: Clean markdown outline ready to write from.
Tools: Web Search (for finding relevant data points)

Invoke with: “Create a blog outline about AI productivity tools for remote workers”

This produces a ready-to-write outline with researched data points in under a minute.

Limitations

Skills cannot be shared with other users (yet). They cannot trigger other skills. They run in a single conversation context, so multi-hour workflows need to be broken into steps. The quality depends on the model, the system prompt, and the complexity of the task. Simple, well-defined tasks automate best. Ambiguous, judgment-heavy tasks are harder to skill-ify.