Skill, automation, or agent? How to know what you’re actually building.
Three types of AI builds, when each one fits, and step-by-step examples so you can build the right one yourself
“Can I use Claude to build an automation?”
I get this question repeatedly. And the honest answer is: maybe, but that’s usually the wrong question to start with.
Because most people are reaching for a tool before they know what they’re actually building. Skill, automation, agent. They get used interchangeably, and that confusion is exactly how founders end up building the wrong thing.
Once you understand the difference, you stop wasting time building the wrong thing. And you stop feeling like everyone else is ahead of you just because they use fancier words.
Let me break all three down. I’ll explain what each one is, when it’s the right choice, and then walk you through building a real example step by step.
1. The Skill: a saved prompt you reuse
A skill is the simplest of the three. It’s a prompt you’ve written once, tested, and saved so you can reuse it whenever you need it.
No code. No integrations. No workflow builder. Just a well-crafted prompt that you paste into Claude, and it gives you a reliable output every time.
Most people underestimate skills because they sound too simple. But a good skill replaces a task that used to take you 30 to 60 minutes and turns it into a 2-minute copy-paste job.
When to use it
Use a skill when:
- You’re doing the same type of task repeatedly
- The task has one input and one output (drop something in, get something out)
- You want speed and simplicity, not a system
Example: Newsletter to social posts
You publish a newsletter every week. You need 3 social media posts from each one. You’re doing it by hand every time, rereading the newsletter, pulling out the best bits, rewriting them for LinkedIn or Instagram.
That’s a skill. Here’s how to build it.
Step 1: Write the prompt
Open Claude or ChatGPT and write a prompt like this:
> You are a social media strategist for a personal brand in the [your niche] space. My audience is [describe your audience].
> I’m going to paste my latest newsletter. Create 3 social media posts from it:
> Post 1: A hook-led LinkedIn post (under 200 words) that takes the single most contrarian or surprising insight from the newsletter and frames it as a standalone thought. Start with a one-line hook that would make someone stop scrolling.
> Post 2: An Instagram carousel outline (5 to 7 slides) that teaches the most actionable part of the newsletter. Slide 1 is a bold hook. Final slide is a CTA.
> Post 3: A short-form video script (under 60 seconds) that tells the story or example from the newsletter in a conversational, direct-to-camera tone.
> Match my tone: [describe your tone, or paste 2 to 3 example posts].
Step 2: Test it
Run it with your last 2 or 3 newsletters. See if the output matches your voice and quality bar. Tweak the prompt if it doesn’t. Maybe you need to add “don’t use emojis” or “always end LinkedIn posts with a question.”
Step 3: Create the skill
Type /skill-creator into a Claude Cowork chat and paste the prompt somewhere you can grab it in seconds. Name the skill and ask claude to create it based on the provided prompt
Step 4: Use it
Every time you publish a newsletter, paste it in and call your skill, get your 3 posts, edit the 20% that needs tweaking, and publish. What used to take an hour now takes 10 minutes.
That’s a skill. No code, no integrations, no complexity. Just a prompt that does one job well.
2. The Automation: a fixed chain of steps that runs itself
An automation is a sequence of steps that runs the same way every time, triggered by an event. Something happens, and a chain of actions follows automatically. No human in the loop. No decisions to make. Just: if this, then that, then that, then that.
The key difference from a skill: an automation connects tools and runs without you. A skill still needs you to paste something in and press go.
When to use it
Use an automation when:
- The same sequence of steps happens every time
- It’s triggered by an event (an email arrives, a form is submitted, a payment lands)
- Each step is predictable, there’s no “it depends”
- You want it running in the background while you do other things
Example: Invoice processing pipeline
An invoice arrives by email. Right now, you’re manually opening it, copying the details into a spreadsheet, sending a confirmation email, and logging it in your accounting tool. Same steps every time. Takes 20 minutes per invoice, adds up fast.
That’s an automation. Here’s how to build it.
Step 1: Map the trigger and the chain
Write out the exact sequence:
1. Trigger: Email arrives with an invoice attachment (PDF)
2. Extract the invoice details (vendor, amount, date, invoice number)
3. Add a new row to a Google Sheet with those details
4. Send a confirmation email to the sender (”Received, thank you”)
5. Create an expense entry in QuickBooks (or your accounting tool)
That’s the chain. Every step is fixed. No decisions, no branching.
Step 2: Pick your orchestrator
You need a tool that connects these steps. The most common options:
- **n8n** (open source, self-hosted or cloud, my personal choice)
- **Make** (visual, good for non-technical builders)
- **Zapier** (simplest, but gets expensive at scale)
For this example, I’ll use n8n.
Step 3: Build the workflow in n8n
Here’s how the workflow looks, node by node:
**Node 1 — Email Trigger.**
Set up a Gmail or IMAP trigger node that watches for emails matching your criteria (e.g., subject contains “invoice,” or from a specific set of vendors). n8n checks your inbox on a schedule and fires the workflow when a match lands.
**Node 2 — Extract the PDF.**
Add an “Extract from File” node. This takes the email attachment (the PDF) and pulls the text content out of it. For simple invoices, n8n’s built-in PDF parser works. For messier formats, you can route it through an AI node (Claude or GPT) with a prompt like:
> Extract the following from this invoice: vendor name, invoice number, date, line items, total amount, and currency. Return it as JSON.
**Node 3 — Write to Google Sheets.**
Add a Google Sheets node. Map the extracted fields (vendor, amount, date, invoice number) to columns in your spreadsheet. Each invoice becomes a new row.
**Node 4 — Send confirmation email.**
Add a Gmail node (or your email tool). Set it to reply to the original sender with a template:
“Hi [vendor name], confirming receipt of invoice [number] for [amount]. This has been logged. Thank you.”
Map the fields dynamically from the extracted data.
**Node 5 — Log in QuickBooks.**
Add a QuickBooks node (or an HTTP request if your accounting tool has an API). Create a new expense or bill entry with the invoice details.
**Step 4: Test it**
Send yourself a test invoice email. Watch the workflow fire. Check that the spreadsheet row is correct, the confirmation email looks right, and the QuickBooks entry is accurate. Fix any mapping errors.
**Step 5: Activate and forget**
Turn the workflow on. Every invoice that hits your inbox now gets processed automatically. You check the spreadsheet once a week to make sure nothing looks off. That’s it.
20 minutes per invoice, eliminated. If you process 20 invoices a month, you just saved yourself over 3 hours monthly on a single workflow that took an afternoon to build.
3. The Agent: AI that makes decisions
An agent is AI that you give a goal to, and it figures out the steps on its own. It can read, reason, decide what to do next, pull in the right information, and take action.
The key difference from an automation: an automation follows a fixed path. An agent navigates. It handles ambiguity. It makes judgment calls.
This is the most powerful of the three, and the most misused. People reach for agents when a simple automation would do the job. But when you genuinely need reasoning, branching logic, and adaptability, an agent is the right call.
When to use it
Use an agent when:
- The task involves decisions that depend on context
- Different inputs need different responses
- It needs to pull from multiple knowledge sources
- A fixed chain of steps can’t cover all the scenarios
Example: E-commerce customer support agent
A customer messages your online store. It might be a question about sizing. It might be a complaint about a late order. It might be someone asking for a refund. It might be a product question that requires pulling from your FAQ.
Each message needs a different response, different information, sometimes a different action entirely. A fixed automation can’t handle that. A skill can’t either. You need something that reads the message, understands the intent, and responds appropriately.
That’s an agent. Here’s how to build it.
Step 1: Define the goal and boundaries
Before you build anything, write down:
- **Goal:** Respond to incoming customer messages accurately, helpfully, and in our brand voice. Resolve what can be resolved. Escalate what can’t.
- **What it CAN do:** Answer product questions, check order status, explain return policies, provide sizing guidance, offer discount codes for service failures.
- **What it CANNOT do:** Process refunds (escalate to human), make promises about delivery dates that aren’t in the system, respond to legal complaints.
- **Escalation rule:** If the agent isn’t confident (e.g., angry customer, unusual request, anything involving money over a threshold), hand it to a human with full context.
These boundaries matter. An agent without guardrails will eventually do something you didn’t want. Define the edges first.
Step 2: Build the knowledge base
The agent is only as good as the information it can access. Prepare these documents:
- **Product FAQ:** Every common question about your products (sizing, materials, shipping times, care instructions)
- **Return and refund policy:** The exact policy, word for word, so the agent quotes it correctly
- **Order status guide:** How to interpret order statuses from your system (processing, shipped, delivered, delayed)
- **Brand voice guide:** 5 to 10 example responses showing your tone (friendly but professional, no corporate speak, empathetic when things go wrong)
- **Escalation criteria:** A clear list of when to hand off to a human
Upload these as documents into your AI tool. In Claude, this would be a Project with these files attached. In n8n, you’d connect a spreadsheet or vector store (like Pinecone or Supabase) and embed these documents.
Step 3: Write the system prompt
This is the core instruction that tells the agent how to behave:
> You are a customer support agent for [Store Name]. Your job is to help customers quickly, accurately, and warmly.
> When a customer message comes in:
> 1. Identify the intent: Is this a product question, order enquiry, complaint, return request, or something else?
> 2. If it’s a product question, search the Product FAQ and respond with the relevant answer.
> 3. If it’s an order enquiry, look up the order using the provided order number and share the current status.
> 4. If it’s a complaint or negative experience, acknowledge their frustration first, then offer a resolution within your authority (discount code, free shipping on next order, expedited reshipping).
> 5. If it’s a return or refund request, share the return policy and guide them through the process. If they request a refund that exceeds [amount], escalate to a human.
> 6. If you’re unsure, or the customer is angry and escalating, hand off to a human team member immediately. Include the full conversation and a summary of the issue.
> Tone: Friendly, direct, empathetic. No corporate jargon. Talk like a helpful person, not a chatbot.
> Never make up information. If you don’t have the answer, say so and escalate.
Step 4: Connect the channels
Depending on where your customers reach you:
- **Website chat:** Use a chat widget (like Tidio, Intercom, or a custom widget) that sends messages to your agent via API.
- **Email:** Use n8n to watch your support inbox. When an email arrives, send the content to the agent, get the response, and send it back as a reply.
- **WhatsApp or Instagram DMs:** Use the platform’s business API (or a tool like Respond.io) to pipe messages to the agent.
In n8n, the flow looks like this:
1. Message arrives (from any channel)
2. n8n sends the message + conversation history to Claude (or your chosen LLM) with the system prompt and knowledge base context
3. Claude returns a response
4. n8n checks: did Claude flag this for escalation? If yes, forward to a human (Slack message, email to your team). If no, send the response back to the customer through the original channel.
Step 5: Add the guardrails
This is the step most people skip, and it’s the most important one.
- **Confidence check:** If the agent’s response includes phrases like “I’m not sure” or “I think,” don’t send it. Route it to a human.
- **Sentiment detection:** Add a simple check. If the customer’s message contains strong negative language, escalate regardless of the content.
- **Rate limit:** If the same customer sends more than 3 messages in quick succession, they’re frustrated. Escalate.
- **Human review period:** For the first 2 weeks, have every agent response reviewed by a human before it goes out. This is how you catch edge cases and tune the system before going fully autonomous.
Step 6: Test with real scenarios
Before going live, test with at least 20 real customer messages (pull them from your support history). Check:
- Did it get the answer right?
- Did it escalate when it should have?
- Did it sound like your brand?
- Did it make anything up?
Fix what needs fixing. Tune the prompt. Add to the knowledge base.
Step 7: Go live with a safety net
Start with the agent handling 50% of incoming messages (route the other 50% to your team as normal). Monitor for a week. If it’s performing well, increase to 80%. Keep a human review queue for edge cases.
You’re not replacing your support team. You’re giving them a first responder that handles the routine so they can focus on the conversations that actually need a human.
The decision tree
Here’s the simplest way to figure out which one you need:
Ask yourself: does it require reasoning?
- No, and it’s one task: That’s a skill. Write a prompt, save it, reuse it.
- No, and it’s a chain of tasks: That’s an automation. Wire it up in n8n or Make, trigger it, and let it run.
- Yes, it needs to understand context and decide what to do: That’s an agent. Give it a goal, a knowledge base, and guardrails.
If you’re not sure, start with the simplest option. A skill can become an automation later. An automation can grow into an agent when you need it to. You don’t have to get it perfect on day one.
The expensive mistake is building an agent when all you needed was a saved prompt. Or trying to automate something that actually requires judgment.
Where most people go wrong
I want to be honest about something. The AI space right now is obsessed with agents. Every post, every course, every tool is pushing agents as the answer to everything.
But in my work with founders and small businesses, the vast majority of their problems are solved by skills and automations.
That’s not because agents aren’t powerful. They are. But they’re also more complex to build, harder to maintain, and more likely to break in unexpected ways. If a simple prompt does the job, use the simple prompt.
Build what’s appropriate. Not what sounds most impressive.
Where to start
If you’ve read this far and you’re thinking “okay, I need to build something,” here’s my advice:
1. Pick one task that you do repeatedly and that drains your energy
2. Ask yourself: is it a skill, an automation, or an agent?
3. Build the simplest version first. Don’t over-engineer it.
4. Use it for two weeks. See if it holds up.
5. Then decide if it needs to grow.
That’s how real AI adoption works. Not a massive overhaul. One thing, done properly, that gives you time back.
What’s the one task you’d love to hand off? Reply to this email, describe it in one sentence, and I’ll tell you whether it’s a skill, an automation, or an agent, and where I’d start. I read every response.
Hi, I’m Jomana. Mother of two (third on the way), AI automation developer, and someone who burned out before learning that systems beat hustle.
I help overwhelmed founders adopt AI with clarity, one bottleneck removed at a time.