
You have a gap in your business and three ways to close it with AI: write a skill, deploy an agent, or build software. They cost differently and they fail differently. Most people choose by what feels current, and that's how you end up with an agent that can't handle the cases that matter, software that costs more to maintain than the problem it solved, or a library of skills nobody opens.
Three questions settle most of it. Is a person present when the work runs? How much does the work vary? What does a mistake cost?
What are Skills, Agents and Software?
A skill is a reusable package of instructions, examples, and reference material that an AI loads when a task calls for it. A person starts the work, the AI follows your method, and the person reviews the result. A human is in the loop every time. Building one takes hours, not weeks. Mostly you're writing down how you do the thing.
An agent is an AI system given a goal and a set of tools, then left to work through the steps itself: reading, deciding, acting, checking. Nobody watches each step. You define what it can touch, when it stops and asks, and how you review what it did.
Software is code that does one thing the same way every time. Same input, same output. It might call a model for a narrow step, but the logic is fixed.
The costs follow from that. A skill is cheap to build and cheap to change, but every run costs a person's attention. An agent costs more to build, charges per run, and needs ongoing supervision. Software costs the most up front and almost nothing per run, but every change is a project.
Who's in the loop?
If a person is present when the work runs and reads the output before it goes anywhere, write a skill. The person who ran it owns the result, can explain it, and can fix it on the spot.
An agent takes that person out of the middle. That's the point, and it's also the risk. When an agent approves, sends, or changes something, nobody has read it first. Accountability moves into the design: what the agent can touch, what it has to escalate, and who reviews a sample afterward. If you can't name that reviewer, you're not ready to deploy an agent.
Software moves accountability into the system. That works when the rules are known. You can test it, audit it, and point to the line that made the decision.
Accountability is expensive. If 95% of your invoices are routine, paying a person to read all of them is waste. That's the case for an agent. But the question isn't whether it handles the hard 5%. It's whether you'll notice when it gets one wrong.
How much the work varies
Identical every time means software. Patterned but messy means an agent. Different every time means a skill.
If you'll do the task a handful of times a year, write a skill. An agent's setup cost never pays back. A skill is also the right home for a process that's still changing, because changing a skill means editing a document.
Agents earn their keep on work with a predictable core and a messy edge. Automate the 80% that's predictable and route the 20% to a person. That only works if you've sorted the two correctly. Get it wrong and you've built something that escalates everything, or worse, escalates nothing.
Software is for high volume with fixed rules: thousands of transactions a day, each one mattering, with logging and tight integration. An agent can't give you that level of control, and a person can't sustain that volume.
Judgment versus execution
Execution follows a defined process. Judgment decides which process applies, or whether any does.
Models can exercise real judgment now, and that's why they're useful. The question is whether you can check it. With a skill, you check every time, because you're reading the output. With an agent, you check a sample. With software there's nothing to check, because there's no judgment, only rules.
So if judgment shows up at every step, write a skill. If it shows up at a few decision points, deploy an agent that escalates those. If it only matters when something breaks, write software and keep a person on call.
When to Start with a skill
This is the rule I'd follow. Write the skill first, even if you're sure you'll end up with an agent.
Writing it forces you to say how the work actually gets done. Running it twenty times shows you where the work varies, what you correct every time, and which steps you never touch. That's the spec for everything that comes after.
Then promote it. When you're approving the output without editing it, the skill is ready to become an agent. When parts of the agent never vary, pull them out as software and let the agent call them. Mature workflows usually end up as all three: software for the fixed parts, an agent for the patterned middle, and a skill for the judgment calls a person still owns.
Don't skip the first rung. Teams that jump straight to an agent automate a process they never wrote down, so they scale its flaws. Fix the process first, then automate it.
Where each one breaks
Skills depend on someone remembering to use them. They drift when instructions get vague or the underlying model changes. A skill nobody runs is just a document.
Agents work inside their scope and fail quietly outside it. They need tuning every time your process changes. They don't remove the human cost. They move it from execution to oversight.
Software is rigid, and every line is a line to maintain. Budget for the maintenance, not only the build. And if what you're building is table stakes, buy it. Build only what sets you apart.
Constraints and hybrids
Sometimes the right answer isn't available. You don't have the budget for software or the time to tune an agent. Then take the interim option on purpose: a skill now, with the plan to promote it. That's a pragmatic call, not a failure.
Hybrids are harder to maintain, with more handoffs and more ways to fail. They're worth it when the problem is complex enough to need them. When one approach would do, use one.
Check your decision early
Validate the choice by whether it's solving the right problem at the right cost, not by whether it works.
Skill: Is it being used, and are your corrections going down? If you fix the same thing every run, fix the skill. Check within the first few weeks.
Agent: Look at the escalation rate and the error rate on sampled output. Too many escalations means it isn't carrying enough of the work. Too few means it's probably missing mistakes. Check within the first few months.
Software: Is the maintenance burden sustainable? If you're constantly fixing it, it costs more than the problem did. If it runs fine and nobody uses it, you built the wrong thing. Check within the first year.
The hard part is admitting the first choice was wrong. Most people double down instead, with more tuning, more patches, and more training, because quitting feels worse than paying. Switch early, while it's still cheap.
Skills are flexible and cheap, but they need a person. Agents scale, but they need supervision. Software is predictable, but rigid. Pick by who's in the loop, how much the work varies, and what a mistake costs. Then start with the skill.