During the first wave of generative AI, n8n was everywhere. Every week brought another workflow with agents, tools, memory, RAG, and an automation that promised to solve half the company before coffee.
Then came a correction.
Tools like OpenCode and Claude Code started producing good source code. When the output is structured, testable, and reasonably easy to understand, n8n can look like an unnecessary visual layer. Why connect twenty nodes by dragging boxes around if an agent can write a complete implementation in seconds?
I left n8n alone for a while.
Now I'm back. Not to build the final product.
The problem I'm trying to solve
I've started structuring a purpose-built agent to automate a process with many steps, branches, and intermediate decisions. It's not the usual linear flow of “receive an email, call an API, save the result.”
There are states. Exceptions. Retries. Data that changes the path. Responses that require another lookup. Cases where the process has to stop and ask a human to intervene.
My first problem isn't performance or cost per execution. My first problem is understanding exactly what I'm building.
That is where n8n makes sense again.
1. It lets me iterate quickly
The agent is accessed through an API, and Asere helps me change its behaviour, test cases, and repeat the cycle quickly.
I can change a condition, run the workflow, see what happened, and adjust it again. I don't have to design the final architecture before checking whether the basic idea works.
That matters when I'm still discovering the process. Some rules only appear when I test real cases. Others are hidden inside an exception nobody documented.
n8n gives me a place to experiment without turning every hypothesis into a permanent architectural decision.
2. Code can hide problems too
There is an uncomfortable part of AI-assisted development.
When an agent produces a lot of code, reading all of it with the attention it deserves can be difficult. The result may be correct. It may compile. It may pass some tests. We still may not understand what it does at every branch.
That is where blind approvals appear: accepting what the agent proposes because reviewing every detail feels too expensive.
It's bad practice. We know that. It still happens.
I'm not making an abstract criticism. It's a very concrete temptation when hundreds of lines look reasonable and you want to close the task.
n8n's visual format puts the problem in front of me. If a branch doesn't make sense, I usually see it. If the workflow has become a mess, I see that too. If one node is doing too much, it's exposed.
A diagram doesn't replace technical review. It makes it harder to pretend we've understood something we haven't.
3. I can split the complexity into subflows
When the workflow gets too large, I split it.
One subflow can validate data. Another can decide which path to take. Another can perform a specific action. Another can handle errors and retries.
This doesn't remove the complexity. It moves it into smaller places where I can review it without holding the entire process in my head.
For now, that's the main advantage: n8n acts as a shared representation of the agent's behaviour. Not only the place where it runs.
I can look at the workflow and explain what happens. I can spot a badly placed decision. I can compare two versions. I can change one piece without losing sight of the whole path.
n8n may not be the final product
I know n8n may not be the right tool for the finished version of a product with demanding performance, operational control, or maintenance requirements.
That isn't the question I'm trying to answer yet.
This system is still a prototype. I want to validate whether the automated process solves a real client problem and whether the agent's decisions produce useful results. Once that is clear, part of the logic may belong in a Cloudflare Worker or another more specific implementation.
Doing it the other way around would be an expensive way to be wrong: build a technically elegant solution first, then discover that the workflow solves the wrong problem.
If the prototype works, we'll know what the system has to do, where the exceptions are, and which parts deserve a more solid implementation.
If it doesn't, at least we won't have spent weeks turning a bad idea into a beautifully programmed product.
That's why I've come back to n8n. Not because code stopped mattering. I want to write the final code when I understand the process that code has to represent.
Sometimes the fastest tool isn't the one that produces the final solution. It's the one that lets you find out, without too much ceremony, whether the solution deserves to exist.