For a decade automation meant snapping blocks together. Now you declare the outcome in a sentence and it builds itself. Ten nodes collapse into one prompt — the grammar of automation itself has shifted.
Most automation users learned by snapping blocks together. Make, n8n, Zapier — a canvas with nodes, lines between them, settings inside each. Intuitive, but the canvas turns to spaghetti once things get real. I lived in that world for years. Then I watched a developer, Jono Catliff, say he had "replaced n8n with Claude Code" in a demo video. The shock was real. Ten nodes collapsed into one prompt.
Today let's unpack what changed. The point isn't Claude Code versus n8n. The point is the grammar of automation itself is shifting. Slowly now.
There are two ways to build automation.
First, assembly automation. You pick blocks and connect them. "Read file" block → "extract data" block → "create folder" block → "save" block. You need to know what each block does, and you decide the order. The tool only follows the flow you drew. The designer is you.
Second, declarative automation. You describe the outcome in words. "Read invoice PDFs, sort by month, save a CSV." The AI picks the blocks, orders them, runs them. The tool designs the flow. The designer is the AI.
The difference isn't "drag vs type." It is who designs. Assembly wants you to know every step. Declaration only needs you to know the outcome.
Laundry analogy. Assembly is you standing next to the washer saying, "first cold water, then detergent, then ten minutes, then two rinses…" You must drive the sequence. Declaration is saying, "five shirts, please, make them clean." You don't need the middle steps at all.
Here is Jono Catliff's real experiment. Task: process 42 invoice PDFs. Extract date, vendor, amount from each, sort into monthly folders, roll up a CSV, flag duplicates, flag any invoice over a threshold.
In n8n or Make you'd reach for many nodes.
Over ten nodes wired on screen, each with its own settings. First build: three hours or so. And if PDF formats shift a little, multiple nodes need edits. Maintenance is a grind.
In a Claude Code terminal you type,
"Read these 42 invoice PDFs, extract date, vendor, amount, sort into monthly folders, produce a CSV. Flag duplicates. Flag anything over $1,000."
That's it. Claude writes a script, runs it, checks the results. Midway, when a PDF parses weirdly, it retries on its own. In minutes 42 invoices are sorted, the CSV exists, flags are set. You wrote the outcome, not the ten nodes.
Home kitchen. To make carbonara at home you open a recipe. "300g pasta, 3L water, one spoon of salt, boil 8 minutes, 2 spoons olive oil in a pan, 3 cloves garlic, 50g bacon…" Every step is there. You assemble your way through.
At a restaurant it's different. You say, "carbonara, please." How long the pasta boils, how much salt — the kitchen handles. You declared the outcome. Hundreds of mid-process decisions stay with the expert.
Old-school automation is the home kitchen recipe. Assemble well to get a result. Declarative automation is the restaurant order. Declare the outcome, hand the middle to the expert (the AI).
Same task, both ways.
| Item | Assembly (n8n) | Declarative (Claude Code) |
|---|---|---|
| Design time | ~3 hours | ~5 minutes |
| Nodes or lines | 10+ nodes | 1 prompt |
| Maintenance (format change) | Edit several nodes | Edit one prompt line |
| Learning curve | Dozens of node types | Practice natural language |
| Running cost | Monthly subscription | Token usage |
| Complex analysis in parallel | Hard (extra plumbing) | Easy (same prompt) |
Three hours vs five minutes. Thirty-six times faster. And the real gap shows when you need analysis. Assembly tools need yet another node to answer "who are the top ten clients?" Declarative tools? Add "and list the top ten clients" to the same sentence. Done.
Here is the aha.
The shift in automation isn't "more features." It is that design authority moved from human to tool.
One question tells you which flavor.
"Will I run this once, or every day?"
Two answers.
First-time tasks. Quick checks. Anything that needs analysis mixed in. Declarative tools like Claude Code shine. Describe it and you're done.
Daily 7 AM jobs. Event-triggered flows. Things stitched to many external services that must run rock-steady. Assembly tools like Make or n8n shine. Built once, they run in the cloud while you sleep.
Three-word memory hook: Once declare. Daily assemble. Boundary is repetition.
Two kinds of automation run my YouTube channel.
Daily repeating — assembly. New video triggers a community tab post, the thumbnail gets reshaped to storage standards, uploads to the right buckets. Built once in n8n-style tooling and it hums every day. No hands needed.
One-off plus analysis — declarative. "Pull my top ten videos this month and find what they share." "Read 300 comments and find the five recurring questions." These go into Claude Code as a sentence. Results differ each time, and I can say "now look from another angle" in the same loop.
The two run side by side. The robot handles the repeat, I handle the judgment with AI through conversation.
Let me pull it together.
Two flavors of automation exist. Assembly of blocks, and declaration of outcomes. Assembly ruled for a decade, and the human was the designer. Declaration is finally possible, and the AI is the designer. This isn't a story about a single tool — the grammar of automation is rewriting itself.
The names n8n and Claude Code may both change. The principle holds. Declarative tools will get smarter. Assembly tools will still be needed. The skill is sensing when to use which. Once jobs go declarative. Daily jobs go assembly. One judgment splits time and cost. Tools change. The distinction doesn't.
Three words to close.
Once declare. Daily assemble. Question repeats.