Most of your work isn't repetitive enough to automate the old way

Workflow automation fails for most people for a reason the tools rarely admit: most real work isn't repetitive enough to fit a template. The steps look routine from the outside, but up close they're full of small judgment calls and personal shortcuts that no prebuilt automation expects. So the automation either never gets built, or it gets built and quietly breaks the first time the work doesn't match the script.

We learned this the slow way. Before building Incredible, we ran 167 discovery calls with people who wanted their repetitive work gone. We went in expecting to hear about price and setup complexity. What we heard instead changed what we built.

What 167 people told us about their "repetitive" work

Three things came up over and over across those calls.

The first was time. People didn't have any to spare for building automations. Learning a tool, mapping out a flow, and configuring each step is its own project, and it's the one nobody has a free afternoon for. The thing meant to save time costs time up front, so it stays on the someday list.

The second was trust. The ones who had tried AI workflow builders found them unreliable. Close enough to be tempting, not dependable enough to hand a task they'd then have to check anyway. And a tool you have to double-check hasn't saved you the task.

The third one is the one that reframed everything, and it's the heart of this. When people walked us through the work they actually wanted gone, it almost never looked like a clean, repeatable process. It was individual to them. Full of little decisions, exceptions, and the specific way they move through their own apps. The steps were consistent for that person, but they matched no template, because they were nobody else's steps.

That third finding is the quiet reason the first two even happen. Building takes forever and tools feel unreliable largely because the work being forced into them was never template-shaped to begin with.

Take a task that sounds perfectly automatable: reconciling invoices against a spreadsheet. On paper it's the definition of repetitive. In practice, the person doing it knows that this vendor always sends the total in the email body, that one client's invoices skip a PO number so you check the project code instead, that anything over a certain amount gets flagged for a second look. None of that lives in a manual. It lives in the head of the person who's done it two hundred times. A template never sees those rules, so it either ignores them or chokes on them. The task looked generic. It was anything but.

Why automation built on templates keeps failing

This isn't only our read from a few conversations. The failure shows up in the industry numbers, and the reason behind it matches what we heard.

EY's report Get ready for robots estimated that 30 to 50 percent of initial RPA projects fail. The pattern behind those failures is consistent: practitioners in Gartner's community point out that an automation only works as long as the process it copied stays exactly the same, and that a product update or a changed screen can render it useless overnight.

Sit with that for a second, because it's the whole problem in one line. Template and rule-based automation assumes the work holds still. Real work doesn't. It has hidden variability baked into it, the exceptions and judgment calls that felt too small to mention but show up on every other run. The bot doesn't break because the bot is bad. It breaks because the task was never as repetitive as it looked.

And the break is worse than no automation at all. A manual task that goes wrong, you catch in the moment, because you're the one doing it. An automated one fails silently. It keeps running against a screen that moved or a field that changed, producing wrong output for days before anyone notices, and then someone spends an afternoon untangling what it did. You didn't just lose the time you hoped to save. You added cleanup on top.

Which means the common advice, "just automate your repetitive tasks," quietly skips the hard part. The honest question isn't whether a task repeats. It's whether it repeats the same way, every time, for everyone. Most of the work people actually hate doesn't.

"Repetitive" is the wrong test

Here's the reframe that came out of those 167 calls, and it changed how we think about what's automatable.

The useful question isn't "is this task repetitive?" It's "is this task consistent for me?" Those sound the same and they're not.

A task can be completely individual to you, your apps, your shortcuts, your particular order of operations, and still be the exact same task every single time you do it. That's most of the work people want gone. It's not generic enough to template, but it's stable enough to hand off. The old tools can't tell the difference, so they demand the task be generic, and then they fail when it isn't.

That distinction is the gap. Plenty of work is too unique for a template but consistent enough to teach.

So can you automate work that isn't clean and repetitive?

Yes, but not by building it. You teach it.

If the reason templates fail is that everyone's work is a little different, then the fix isn't a bigger library of templates. It's letting each person show their own version, once. Instead of configuring a flow to match a generic pattern, you record yourself doing your task, explain it as you go, and let the software learn your specific way of doing it. That's the approach we ended up building, and it's covered in full in our guide to teaching an AI to do your work by showing it once.

The difference matters because teaching captures the individual stuff that templates throw away. The exception you always handle a certain way, the shortcut only you take, the order you do things in. That's not noise to be standardized out. For your work, it's the actual task.

What this means for choosing an automation tool

None of this means template tools are useless. It means they're for a narrower slice of work than they're sold for.

If a process is genuinely standardized, high-volume, and stable, the kind of thing a whole team does the identical way, rule-based automation and the big no-code builders are a good fit, and worth the setup cost. That's their home turf.

But if the work is yours, shaped around how you specifically operate, full of small calls that don't generalize, then the test that matters is consistency, not repetitiveness. Work like that has been stuck in the manual pile for years, not because it couldn't be automated, but because the only tools on offer demanded it look like everyone else's. It never did. The good news is it no longer has to.