How to Build Your First AI Automation (Step-by-Step Tutorial)

What if you could type a single phrase, like "research Acme Corp" or "draft a proposal for Sarah," and get back a polished, ready-to-use result in under two minutes? That is what a well-built AI skill does. It is a plain text instruction file that turns a vague AI interaction into a reliable, repeatable business tool. No coding. No app subscriptions. Just a file you drop into a folder.

The simplicity is both the appeal and the trap. "Just a text file" makes it sound trivially easy to write a good one. It is not. Most people's first attempts produce generic output the AI would have given anyway, just with extra steps. This tutorial shows you how to build a skill that actually changes what you get back, step by step, with a complete working example you can copy.

What a skill file actually is

A skill file is a simple text document with two parts: a short header that names the skill and describes when it should activate, and a body that contains the step-by-step instructions the AI follows. Think of it as a recipe card. The header says what dish it is for, and the body tells the chef exactly how to make it.

Here is the minimal structure:

---
name: your-skill-name
description: When to use this skill and what it does — Claude reads this to decide relevance.
---

# Your Skill Title

Instructions for Claude go here.

The name field is just a label. The description field is the important part. The AI reads it to decide whether this skill is relevant to what you just asked. If your description is vague, the skill either activates when you do not want it or never activates at all.

The body is where the real work happens. This is the part most tutorials skip over.

Installing a skill (easier than you think)

Place the skill file in the folder where Claude looks for them. The exact location depends on which version of Claude you use:

• Claude Code (terminal version): Put the file at ~/.claude/skills/your-skill-name/SKILL.md, and each skill lives in its own subfolder
• Claude Cowork (desktop version): Drag the file directly into your workspace

Start a new conversation. That is it. The skill is live and ready to use.

Building a real skill: the prospect pipeline

Let us build something useful. Researching a target company and drafting a personalized outreach email takes 2 to 4 hours manually. A well-built skill does it in 90 seconds. Here is a complete working example. You can copy this file, install it, and use it today.

Here is a complete working example:

---
name: prospect-pipeline
description: Research a company and produce a full outreach package when the user
  says "prospect [company name]". Output includes company brief, decision-maker
  profile, pain hypothesis, two subject lines, and a first-touch cold email.
---

# Prospect Pipeline

When the user says "prospect [company name]", run all five steps below in
sequence. Label each step clearly.

## Step 1 — Company Brief

Research [company name]. Output:
- Industry, stage, and approximate headcount
- Recent product launches, press coverage, or fundraising (last 90 days)
- Current growth priorities based on public signals (job postings, blog,
  announcements)
- One-sentence positioning: what they sell and who buys it

## Step 2 — Decision-Maker Profile

Identify the most relevant decision-maker for a B2B service engagement:
- Title (e.g., Head of Growth, VP Operations, Founder/CEO for <50 employees)
- LinkedIn signals if available: recent posts, career history, shared context
- Warm angle — something they've said publicly that you can reference

## Step 3 — Pain Hypothesis

Based on Steps 1–2, formulate a specific pain hypothesis. Requirements:
- Name the specific problem, not a category ("SMB merchants churn in the
  90–180 day window" not "retention problems")
- Cite at least one observable signal that supports the hypothesis
  (help center article, job posting, public comment, product changelog)
- Translate the pain into a concrete cost or opportunity

## Step 4 — Subject Lines (A/B)

Write two subject line options:
- Option A: Leads directly with the pain hypothesis from Step 3
- Option B: References something the decision-maker published or said

Keep both under 60 characters.

## Step 5 — First-Touch Email

Write a cold email with these constraints:
- 4 sentences maximum
- Sentence 1: reference something specific from Step 2 (show you did the work)
- Sentence 2: state a concrete outcome from a similar engagement
- Sentence 3: connect that outcome to the pain from Step 3
- Sentence 4: single low-friction ask (15-minute call, one specific question)
- Sign with [Your name]

Do not use filler phrases: "I hope this finds you well", "I came across your
profile", "I wanted to reach out". Write like a peer, not a vendor.

This is 37 lines of instructions. It produces output that would take 3-4 hours to do manually. The specificity is doing the work. Every vague instruction is an opportunity for Claude to produce something generic.

The four elements that make a skill work

1. A specific trigger, not a general topic

The description should name a specific action, not a subject area. "Helps with prospecting" is a topic. "Activates when someone says 'prospect [company name]'" is a trigger. The second version means the AI knows exactly when to use the skill instead of guessing.

2. Sequential steps, not a single instruction

The most common mistake is treating the skill like a one-liner: "Research this company and write a cold email." The AI will do it, but it will skip steps and compress the output based on what it thinks matters. Instead, break the work into numbered steps the AI runs in order. Each step produces something the next step builds on.

3. Output constraints, not output descriptions

"Write a good cold email" produces different outputs every time. "4 sentences maximum, sentence 1 references something specific about the person, sentence 2 states a concrete result, no filler phrases" produces consistent outputs you can actually send. Define rules, not wishes.

4. Negative instructions for the most common failure modes

Think about the three worst outputs you could get from this skill and explicitly forbid them. For the prospect pipeline: generic subject lines, filler phrases in cold emails, and pain hypotheses without observable evidence. All three are called out directly in the skill above.

What a weak skill looks like

Here is a version of the same skill that looks reasonable but produces mediocre output:

---
name: prospect
description: Helps with prospect research and outreach.
---

# Prospect Research

When I say "prospect [company]", research the company and write
a personalized cold email to the right contact there.

The difference between a weak skill and a strong one is not the length. It's the specificity of the constraints. A 10-line skill with precise constraints outperforms a 100-line skill with vague ones.

The anatomy of a complete skill file

For reference, here is every section a complete skill should have:

1. Frontmatter: name (kebab-case, unique) and description (precise activation pattern + what you get back)
2. Command definition: The exact phrase that fires the skill and what Claude should do with any arguments
3. Numbered steps: Each step labeled, each producing a named output the next step can reference
4. Output constraints: Format requirements, length limits, what to include and what to exclude
5. Negative instructions: Explicit call-outs of the failure modes to avoid

That's it. No YAML configuration files. No environment variables. No API keys. One markdown file.

When to build your own versus buying pre-built

Build your own when the task is specific to your business: your proposal format, your pricing structure, your industry-specific compliance steps. A custom skill that knows your exact workflow will always outperform a generic one.

Buy pre-built skills when the task is universal and you would rather spend Saturday growing your business than writing instructions. Prospecting, content creation, invoice recovery, client onboarding. These look basically the same across most businesses. Pre-built versions have already been refined through multiple rounds of testing to produce consistent, usable output on day one.

If you would rather start with skills that are already written, tested, and ready to use, the Solo Ops Toolkit includes 7 covering the tasks that eat most people's weeks: prospect research, content creation, revenue reporting, proposal generation, competitive analysis, client onboarding, and invoice recovery. Each one follows the exact conventions in this post: step-by-step, output-constrained, with guards against the common failure modes. Average install time: 3 minutes.

What to build next

Once you have one working skill, the second one takes a third of the time. A few high-value skills most solo operators don't have but should:

• Weekly CEO digest: Runs every Friday. It pulls in your pipeline, revenue numbers, and outstanding items, produces a 2-minute text summary you can read before the weekend. No dashboards, no spreadsheets.
• Meeting prep brief: You say prep for [name] and get their LinkedIn summary, recent posts, shared context, and 3 questions to open with. 2 minutes of research compressed to 90 seconds.
• Project close-out: Paste your project notes and get a structured retrospective: what worked, what to standardize, what to charge more for next time. Turns tribal knowledge into reusable process.

Each of these follows the same pattern: one command, explicit steps, tight output constraints. Once you've built the prospect pipeline from this post, you have the template for all of them.