I’ve stopped “trying out” people’s projects.

I often get sent AI tools and automations that people want me to test out and give feedback.

Initially I was flattered to be asked! Kinda cool.

But after 10 or so (yeah, I’m slow) I noticed a pattern.

Far too often what I was being shown just didn’t work.

And didn’t work in a very specific way: the core functionality wasn’t good enough.

I’ll be shown a tool and told about the 15-20 amazing things it can do. But it does all 15-20 things in a substandard manner.

This is peak automation startup syndrome. People breed many-headed beasts.

The core functionality is completely broken, but instead of fixing what matters, they're busy adding more features on top. As if somehow accumulating enough half-baked capabilities will magically solve the fundamental execution problems.

The result? Tools that promise everything and deliver nothing reliably. This is lesson one in building automations that actually work: nail the basics before you even think about expansion.

Let's get started:

The Many-Headed Beast Problem

Feature creep isn't just an annoyance—it's the primary killer of automation projects.

I've watched talented entrepreneurs spend months building elaborate solutions that never quite work. Always on the edge of brilliance but not in a way that can practically be used by a business.

This pattern extends far beyond individual automation projects. The AI startup landscape is littered with companies that followed this exact trajectory. Go onto one the AI tool directories to behold a graveyard of good intentions and poor execution.

They start with a promising core concept, then begin adding features faster than they can stabilise them. The result? Platforms that feel impressive during (highly staged!) demos but fail in real-world usage.

You've probably experienced this: signing up for an AI tool that promises to revolutionise your workflow, only to discover it can't consistently handle the basic task you actually need. Meanwhile, the company's roadmap shows plans for ten more features nobody asked for.

You hopefully manage to cancel before the free trial is up!

The antidote is brutal focus. Your first automation shouldn't be able to juggle seventeen tasks. It should perform one specific function so reliably that people forget they ever did it manually. That is what businesses will pay you for.

The Simple Shape of Every Automation

Before we get into the complexity of where AI fits, let's establish the fundamental structure every automation follows. It's beautifully simple:

Trigger → Process → Result

That's it. Three steps. Every automation you build, whether it's basic or AI-powered, follows this exact pattern.

Trigger: Something happens that kicks off your automation. An email arrives, a form is submitted, a deadline approaches, or data changes in a spreadsheet.

Process: “Something” gets done in response to that trigger. This might be checking information, making calculations, sending messages, or asking AI to analyze and create content.

Result: Something specific happens as output. A record gets created, an email gets sent, a document gets generated, or a team gets notified.

Think of it like a domino effect: the first piece falls (trigger), which causes the middle pieces to fall in sequence (process), leading to a final piece falling exactly where you want it (result).

From here there are levels of complexity:

• maybe multiple triggers need to align

• the process itself could be multi-partite, conditional and branching to huge levels of complexity

• results could be sent to multiple places simultaneously

• etc. etc

But at its core everything starts with a simple trigger, process, result.

This framework forces clarity. If you can't clearly define all three components, your automation is probably too complex or too vague to build reliably.

Where AI Actually Belongs

Here's the crucial insight most people miss: not every step in an automation needs AI.

In fact, most shouldn't.

Shock horror!

The structure of an AI automation is trigger → AI process → result.

Notice AI sits in the middle—it doesn't handle triggers (those are deterministic), and it shouldn't format final outputs (those need to be consistent).

AI belongs in the process step when you need something probabilistic rather than deterministic. If your task involves understanding context, generating human-like text, or making educated guesses based on patterns, that's where AI shines.

But here's what makes this counterintuitive: if something can be done without AI, you probably shouldn't use AI for it.

Why? Because AI is fundamentally probabilistic, not deterministic.

It's going to be creative when you need consistency.

It's going to interpret when you need calculation.This creative unpredictability—AI's greatest strength for complex tasks—becomes a liability for simple ones.

Examples of when NOT to use AI in your automation:

• Extracting structured data from forms (use standard parsing)

• Simple calculations (use built-in functions)

• Exact date/time operations (use system tools)

• Formatting outputs to specifications (use templates)

Examples of when you DO need AI:

• Understanding natural language enquiries

• Writing personalised responses

• Categorising ambiguous content

• Generating human-like communications

So, again for those at the back: if something can be done without AI it should be done without AI!

Designing Your Blueprint

OK let’s pull this all into an automation blueprint for you. We’re going to take ONE question from the last Part and feed it into this prompt:

You are an automation designer specialising in practical, minimal AI workflows for Zapier. Create a blueprint for a simple automation that solves one specific problem.

Problem to solve: [Your problem statement]

Provide:
1. Single trigger event (exact Zapier trigger)
2. Minimal AI process (specific task for ChatGPT/Claude)
3. Exact output format and destination

Design this for maximum simplicity - identify any steps that don't actually need AI and suggest standard Zapier actions instead. Address these validation questions in your design:
- Does this solve ONE clear pain point?
- Is the trigger concrete and specific?
- Is AI truly necessary for this process?
- Would someone pay just for this function?
- Can this be tested quickly?

Keep this as the absolute minimum viable automation.

This prompt creates a concrete blueprint that we can start to build from. Notice it talks about Zapie - we’ll address this shortly. For now just use the prompt to get your blueprint in play.

Common First-Timer Mistakes

If you find yourself looking at the output and thinking it looks too simple that’s a GOOD thing. Here are a couple of things to watch out for - some mistakes to preempt.

The "While I'm At It" Syndrome: Since you're building an automation anyway, why not add just one more feature? This is how simple email automation becomes an entire CRM replacement that doesn't work properly.

The Creative AI Problem: Asking AI to handle deterministic tasks because "it's more intelligent." AI interpreting your invoice numbers differently each time isn't intelligence—it's a limitation of AI!

The Perfect Path Fallacy: Trying to account for every possible scenario from day one. Build for the 80% case first, then iterate when you find the actual edge cases.

Remember, your first automation is proof of concept, not production software. It should work reliably for its core function, not attempt to revolutionise how business gets done. And once we have the basics working we can build from there!

What's Next?

Next up we'll tackle tool selections - specifically why starting with Zapier (despite its limitations) often makes more sense than jumping to more powerful platforms. I'll share the exact thought process for choosing between Zapier, Make, and n8n, plus when each tool makes sense based on your current skill level and project complexity.