The gist
Traditional automation is like a railroad track. The train runs strictly along it. Go off the track, and you crash. Agentic AI is like a construction crew that lays the track for you. The difference isn't how fast the train goes. It's who builds the route, and how.
Key concepts
- What limits traditional automation (Zapier, n8n, Make)
- Where agentic workflows give you a real advantage, and where they don't
- An important nuance: once deployed (deployment means releasing to production, the live environment), the agent's work becomes deterministic, and that's a good thing
- "Doctor vs. pharmacist mindset": why understanding the basics matters
Theory
Traditional automation: powerful but brittle
Zapier, n8n and Make.com are great tools. They run in production (the live environment) at millions of companies. Nobody can call them outdated or bad.
But they have a fundamental limitation: you spell out every step by hand, and the system follows that script exactly.
Say you set up an automation: "When a new lead shows up in the CRM (Customer Relationship Management, the system that tracks your customers) → send a welcome email → add them to a Slack channel → create a task in Notion."
Everything works perfectly until an exception shows up:
- The lead filled out the form twice (a duplicate)
- They typed "Acme LLC" in the "Name" field (not a person's name)
- The lead came from another country and needs a different email template
Traditional automation runs into these cases and... breaks. Or sends the wrong email. Or creates a duplicate task. You get an error notification and go fix it by hand.
The main pain: edge cases (non-standard situations) require manual intervention. The more complex the process, the more edge cases, and the more manual work.
Where agentic workflows win: the build stage
Here's the key insight a lot of people miss:
Agentic AI wins not at runtime (when the automation is already running) but at the stage of BUILDING that automation.
When you tell Claude Code "build me an automation to process incoming leads," the agent (a program that carries out tasks on its own):
- Asks clarifying questions about unusual cases
- Writes the logic for handling duplicates itself
- Adds conditions for different countries
- Builds in error handling
It does all this while building, at the development stage. It acts like an experienced developer who plans for edge cases ahead of time instead of waiting for them to break the system in production.
The traditional approach: you think through every edge case yourself, add conditions in Zapier by hand, test, discover a new edge case, fix it again. That takes a long time.
The agentic approach: you describe the task and its context (the content of the conversation the AI can see), and the agent builds a more complete solution faster.
An important nuance: once deployed, the agent's work becomes deterministic
People don't grasp this right away, but it's critical for quality.
After Claude Code has built the automation and you've deployed it to the cloud (for example, to Cloudflare Workers or trigger.dev), the agent is no longer part of the process. What runs in production is ordinary code: JavaScript and Python (programming languages), API calls (API: Application Programming Interface, the way programs talk to each other).
This is good, not bad. Here's why:
- Predictability: every lead is processed the same way, regardless of the LLM's "mood" (LLM: large language model, the AI behind assistants like Claude)
- Speed: no extra calls to the AI, just clean business logic
- Cost: you don't pay for API calls on every run
- Reliability: no "hallucinations" (a hallucination is a fact the AI made up) in production
An LLM is used in the deployed system only where it's actually needed, for example to generate a personalized email. But the general logic, like "if it's a duplicate → skip it," runs as ordinary code.
To put it another way: the agent is a smart architect who designs the house. But it's the client who lives in the house, not the architect. The architect made the house smart once.
⚠️ A caveat as of October 2026. There are now agents that run continuously too: for example, routines in Claude Code run in the cloud on a schedule, and ChatGPT has a Work mode for long tasks. The lesson's principle doesn't change: the fewer LLM calls in the repeating part of a process, the more predictable, cheaper and faster the system runs. Bring in the model where you need flexibility. What's available on your plan is on the What's current page.
The analogy: laying track yourself vs. a crew
Traditional automation (you lay the track yourself): You pick up each rail, fit it, nail it down. Slow. Every branch (edge case) has to be planned in advance and given its own track. Forget one and the train (your data) goes off the rails.
Agentic workflows (a crew lays the track): You tell the crew: "I need a line from point A to point B. It goes over a mountain, it has to go around a swamp, and I want to be able to expand it later." The crew already knows how to lay track over mountains and around swamps. You control the direction, not every nail.
Important: the crew doesn't ride the rails forever. It builds the line and leaves. After that, the train runs on its own.
Doctor vs. pharmacist mindset: why understanding the basics matters
It's tempting to jump straight into Claude Code and ask it to "build me everything." But that's where a problem shows up.
The pharmacist fills a prescription. They don't diagnose; they carry out the order.
The doctor first understands the symptoms, makes a diagnosis, then prescribes treatment. They know why this medicine and not another.
Claude Code is an incredibly smart pharmacist. It will build what you ask for. But if you don't understand what exactly needs to be built, you'll get a beautiful solution to a problem that isn't yours.
People who skip the basics and jump straight into Claude Code:
- Can't judge the quality of what the agent built
- Can't give a good assignment (a prompt is the text request you give the AI)
- Don't notice when the agent heads the wrong way
- Can't debug when something goes wrong
That's exactly why this course doesn't start with "open Claude Code and write your first prompt." We start with understanding the market, the tools and the structure.
A practical analogy: if you've never cooked, will a kitchen robot help? Yes, but only for very simple dishes. For complex ones, you at least need to understand what "sear until golden brown" means. Otherwise you won't know whether it was done right.
Where traditional automation is still better
Honesty matters: Zapier and n8n aren't dead. They beat the agentic approach when:
- The task is completely standard and never changes
- There are no edge cases at all (for example, "every Monday at 9:00 a.m., send a report")
- You want maximum visual transparency (a drag-and-drop diagram)
- A team without technical skills needs to edit the automation themselves
The agentic approach is better when:
- There are lots of unusual cases
- The process changes often
- You need to handle unstructured data (text, emails, PDFs)
- Speed of building matters more than maximum transparency
Practice
Exercise: Build one workflow by hand in Zapier, then ask Claude Code for the same thing.
Step 1 (15 min): Zapier
- Sign up at zapier.com (the free plan, as of October 2026, gives you 100 tasks a month and two-step Zaps only, which is enough for this exercise)
- Create a simple Zap: "New row in Google Sheets → Send an email through Gmail"
- Pay attention to how many steps, how many clicks and what you had to set up by hand
Step 2 (10 min): compare
- Open a new chat with Claude (no Claude Code yet)
- Type: "I want an automation: when a new row appears in Google Sheets, send an email. What do I need to set up, and which edge cases should I account for?"
- Compare the answer with what you saw in Zapier
What should jump out at you: Claude will right away ask about or mention things that Zapier makes you decide by hand (what to do with duplicates, how to handle empty rows and so on).
Common mistakes
❌ Mistake: Thinking Zapier/n8n are now useless and everything should be done with agents (programs that carry out tasks on their own). ✅ Instead: For standard tasks without edge cases (a weekly report, a simple scheduled mailing), traditional automation is simpler and cheaper. The agentic approach is stronger where there are lots of unusual situations.
❌ Mistake: Leaving LLM calls in production for every action (every lead = an AI call). ✅ Instead: The agent builds the system at the development stage. Once deployed, ordinary deterministic code does the work. The LLM is used only where generation is really needed (personalizing text, classifying non-standard data).
❌ Mistake: Skipping the doctor mindset and asking Claude right away to "build me everything." ✅ Instead: First understand the business process you're automating. What edge cases come up? What does "right" mean for this process? Only then give the agent its assignment.
Comparing the approaches: quick reference
| Factor | Zapier / n8n / Make | Agentic AI (Claude Code) |
|---|---|---|
| Building | Drag-and-drop, by hand | You describe it in plain language |
| Edge cases | You add rules by hand | The agent plans for them while building |
| Runtime | Deterministic code | Deterministic code (after deployment) |
| Runtime cost | Low | Low (no LLM calls) |
| Complex data | Poor (text, PDFs, email) | Good (the LLM understands context) |
| Visibility | High (you can see the diagram) | Low (code + Markdown, a simple text formatting language) |
| Barrier to entry | Low (no-code) | Medium (you need prompting skills) |
| Speed of changes | Slow (manual reconfiguration) | Fast (describe the task again) |
Tools and resources
- Zapier: for hands-on understanding of traditional automation (free plan)
- n8n: an alternative to Zapier. You can install it on your own server (the Community Edition is free) or pick a cloud plan; see prices on the What's current page
- Make.com: another visual automation platform (formerly Integromat)
- Claude.ai: for the comparison test in the practice section
- Claude Code docs: the official documentation
- trigger.dev: a modern platform for running agentic workflows in production
→ See the lesson The agentic market: where we are and why now → See the lesson Default Shift: how to rethink your approach for agentic work → See the lesson The WAT framework: how agentic projects are structured
Key takeaways
Traditional automation is brittle on edge cases: every exception means adding a rule by hand.
Agentic AI wins at the BUILD stage: the agent plans for unusual cases on its own during development.
Once deployed, the agent's work becomes ordinary deterministic code, which is predictable, fast and cheap to run.
"Doctor mindset": understand what you're building and why, or you won't be able to judge the quality of what the agent built.
Next lesson
→ Default Shift: how to change your thinking for the AI era
The mark stays in this browser only and is never sent anywhere. My progress