The difference between Agents, skills, and workflows. A no bs guide for humans

LinkedIn is unreadable right now. Every third post is a weekend vibe-coding project written up like a moon landing. Half the rest come from people whose CEO said "go use AI" and then walked out of the room without saying what for. The accounts with the most followers get the most reach, the reach teaches the feed that this is the good stuff, and the feed serves you more of it.

I wrote about the em dash already. It got blamed for making writing sound like a machine when it was only the tell anyone could spot without training. There's a new tell now. It's the nouns.

Chat. Agent. Skill. Workflow. Automation. Five words for five different things, used at random by people describing what they built.

If you've never watched football, calling a linebacker a strong safety costs you nothing. It costs something the moment you put a lineman on Ja'Marr Chase and ask him to carry a curl route. He gets embarrassed on national television, and it's your fault, because you lined him up there. Nobody watching says "bad call by the coach." They say that lineman is trash.

That is what happens when somebody builds a skill, calls it an agent, and points it at work an agent would be needed for. The thing fails, and the failure looks like AI not working.

Why the wrong words spread

I want to believe most of this is people repeating what they heard from someone they trusted. I'd really like that to be the case, and for most of the feed I think it is.

Then you watch the same voices get booked as thought leaders, in front of rooms full of people who came to find out what's real, and you have to account for motive. Nobody gets into thought leadership for purely altruistic reasons.

A mentor at Salesforce told me something I've never been able to unhear: be careful when someone tells you what you should do, because there's more in it for them than there is for you. Every like, repost, and "this is so insightful" is clout, and clout gets monetized. As a course, as a retainer, as a job. Confidence about these words pays better than accuracy about them.

Apply the rule to this post. I sell this work. What I get out of you knowing the difference is a shorter sales cycle and fewer engagements that open with unwinding a build somebody already paid for twice.

Chat

Chat is where everybody started and it's still the front door. You type a question, the model predicts the first word of the answer, then predicts the next word given that one, then the next, and on until it stops.

That was 2023. The models have gotten much better. The atomic premise hasn't moved.

This is where a lot of hallucination comes from. A confident wrong answer can be likelier than a hedged right one, because confident answers are what most of the training data looks like. You're talking to a machine that guesses what's true, which is roughly your drunk uncle at Thanksgiving explaining politics. Loud, sure of himself, wrong in ways that would take you an hour to unpick. Entertaining, though.

Chat is a scratchpad. Advanced Googling, a diary, a place to think out loud and ask the stupid question you don't want to ask a coworker. That's a real use and I'm in there every day.

It isn't where work happens. Work needs a record of what ran, the ability to run it again the same way, and something that catches it when it's wrong. A chat window has none of the three.

Chat isn't going anywhere. It's how most people get their first "oh, holy shit" moment with AI, and that moment is worth a lot. Treat it as the front door and stop trying to run your company out of the foyer.

Agents

This confusion I understand, because the tools invite it. You're in Claude or Gemini, the thing is doing its little flamboozling animation at the bottom of the screen (the modern rainbow spinning wheel of death), you expand the panel to see what's taking so long, and it says it's running agents. So you conclude you're using agents. You're not wrong. Agents are running. The word still isn't describing the thing you built.

An agent is an automation that can take on a task with unknowns in it. You give it instructions, boundaries, access to the tools it needs, and some sense of how you like things done. Then you give it a goal instead of steps: "get me to inbox zero and file everything." It works out the steps, makes assumptions where you didn't specify, and loops (act, check the result, act again) until it decides it's finished.

Think of a new executive assistant. Sometimes the work comes back better than you'd have done it yourself. Sometimes you look at it and think: what planet are you on right now, why did you think this was a good idea? Both are the same system working as designed. The autonomy that produces the good version is what produces the other one.

The parts you're building are domain knowledge, tool access, rules and guardrails, operating instructions, and the nuance that makes it yours.

Build or buy, there is no third option

If your agent came packaged inside a SaaS tool, you bought it, and you're paying a premium for it.

Run the math on your own bill. A single model call for something like inbox triage costs a fraction of a cent to a few cents in raw tokens, even on the expensive frontier models. Now open the pricing page for the tool doing it. Credits, pay-as-you-go, task-based pricing. Work out what one run of one agent costs you per day. Doing this on tools I use, I land on numbers like $1.20 a day for work that costs the vendor closer to twenty cents. They have costs I'm not counting: retries, storage, evals, support, the engineers. Call it a fair markup and it's still a markup on C+ work you have to check anyway.

Then multiply it out. Per agent, per person, per month. That's where the bill stops being a rounding error. And when a vendor announces they're moving to a more customer-friendly pricing model, go back to the mentor rule and ask what's in it for them.

Building has its own bill. Start on a framework and you skip the infrastructure, which is real work you'd rather not do. In exchange you build on someone else's abstractions and bend your design to their schema. Write it from scratch and you own all of it, including the parts you didn't know existed.

AI made the two easy parts free. Anyone can vibe a working prototype in an afternoon, and generating the artifact costs nothing. The middle is what decides whether the thing survives contact with your business: maintenance, iteration, QA, and learning.

The part everyone skips

Go back to the assistant. If you never tell them what was wrong, they keep turning in the same bad work, and eventually you fire them for a capacity problem you created by never giving feedback. We know not to do that to a person. The same team will run an agent for a year without once telling it what was wrong.

Output comes back wrong, you go find the line in the prompt or the code that caused it, and you patch it by hand. Every single fucking time. You built a system to handle the work and made yourself its error handler.

An agent should take the feedback, work out what it means for the task, and update its own operating instructions so the mistake doesn't come back. The accountability sits with the agent, the same way it would with a person. That's recursive learning.

Some agent platforms build that loop in for you. Build without it and you're paying tokens to make the same mistake on a schedule. And if you're renting someone else's agent and can't reach the learning loop, I'll hold your hand while I say this: you're not ready for agents.

Skills

Skills are the highest-leverage thing most teams can build right now, and the one you almost never see on your feed.

You tend to believe that only after building agents and eating the losses. Coming out of that tunnel you learn there's a time and a place for an agent, and that most of the time the answer is a skill. Sometimes the call is running it up the middle behind a good offensive line. It doesn't trend on Twitter. It gains four yards every time you call it. You don't need to air it out to the $45M receiver posting about his target share.

A skill is a specific set of instructions for something you do the same way every time. A recipe. Scrambled eggs is a skill. So is tonkotsu ramen, which has a lot more steps and still runs the same way every time.

The payoff is diagnosis. Noodles came out gummy? Too much water when you brought the flour together, step 12a. You open that step and fix it. Compare that to a dough ball that's already wrong: add flour, test, add water, test, add flour, and now you have twenty pounds of dough and two bowls of ramen. Fixed steps mean the failure lands on one of them.

The instructions are fixed. The model running them still varies from run to run, so this isn't determinism. What you get is a short sequence of small steps, which is enough to put the failure somewhere you can go read.

Build skills for work that eats time, has to happen, and needs almost no judgment. If you can explain the process to a new hire, you can explain it to a model, and the model can write the skill for you. Then you invoke it and go do something else.

Scope is the other half of it. A skill gets tool access the same way an agent does, and it gets much less of it. You're not handing your assistant a blank check and dropping them at the mall to buy you some clothes. You're giving them $12.23 and telling them to get the blue Stance socks from the Nordstrom three miles down the road. Narrow scope, specific instructions, and after a couple of rounds it gets you 95% of the way there.

Edge cases get handled after the run, not designed in beforehand. Trying to anticipate every case inside an agent's brain is how a six-week project turns into a six-month one.

The test: boring, repetitive, necessary, and needing close to no thinking. That's a skill. Not everything has to be an agent.

Workflows and automations

Workflows are the skill's grandparent, in the rocking chair in the corner, drooling a little, telling you about the time they met Rutherford B. Hayes at the train station in Biloxi.

Give them their due. They worked, they still work, and a lot of the world runs on them. Zapier, Workato, and their relatives take data from one place, do something to it, and put it somewhere else, forever, for very little money. No reasoning, no judgment, and none needed.

They're brittle, and adding AI to them wouldn't fix it. They were built as a horse and carriage. A carriage is fine until the road changes, and the road under a SaaS integration changes constantly. Given the choice between the carriage and the Mercedes that Kimi Antonelli is driving, you take the car.

The brittleness comes from APIs. The tool's uptime is fine and the UI is fine. Underneath, things move constantly: the object model, the schema, permission sets, validation rules. Each of those changes the shape of the API, and the API is what your workflow talks to. There's no one API to rule them all.

So the provider ships a change, the workflow has no idea anything happened, and it fails. If you're lucky it fails loudly and some developer was kind enough to return an error a human can read. Usually you get a status code and a trace, and you go Google it.

The quiet failure is worse. Nothing errors, the call returns a 200, a field got renamed, and the workflow writes empty values into the destination for three weeks until somebody notices the reports are wrong.

Either way you fix it by hand, then find out the new API doesn't fit the shape the workflow was built around, and now you're asking ops to rebuild it. If your ops team is any good, they'll build you a skill that watches the integration, catches the failure, reads the new docs, and proposes the fix, rather than rebuilding the same brittle thing one more time.

Picking one

There's a time and a place for all four, and getting good at AI is mostly knowing which one a job is asking for.

• Are you thinking, or working? Thinking is chat. Working is one of the other three.
• Do you do it the same way every time? It's a skill, and you should have built it last month.
• Does it need judgment about things you can't specify in advance? That's the only thing that justifies an agent, and only if you can reach its learning loop.
• Is it moving data between two systems with no decisions in it? A workflow is fine. Put a skill in front of the failures.

Get the noun right and the tool picks itself. Get it wrong and you'll spend six months and a lot of money teaching a lineman to cover a curl route.

Hopefully this helps. Hopefully you learned something. Hopefully you got a chuckle. If not, the Lexapro will earn its keep and I won't care as much.