🔁 Deterministic Automation (Make/n8n)
A deterministic automation is a flow of fixed steps: you visually design a sequence that always happens in the same order— trigger → action → action. Tools like Make and n8n are built exactly for this: drag blocks and connect them.
🧭 Main concept
"Deterministic" means no surprises: the same trigger always runs the same steps. You don’t ask the tool to “think” — you lay out the entire path in advance.
- •Trigger — what gets it started (a submitted form, a time, a new row in a spreadsheet).
- •Modules — each block does one thing (send an email, save a record, call an API).
- •Webhook — an address that receives data from outside and starts the flow right away.
💡 Practical tip
If you can draw the entire task on one sheet as a sequence of arrows that never changes, it's a perfect candidate for no-code. Cheap, fast, and easy to maintain.
the starting point
action blocks
external data
always the same
🤖 Agentic development (AntiGravity)
In agentic development, you don't draw the path: you describe the goal. The AI then writes the code, runs it, sees the error that appeared, and fixes it on its own — repeating the cycle until it works. It’s reasoning, not a script.
You describe the goal
"I want an app that accepts a spreadsheet and generates a summary report." Don't say how—just what.
AI writes and tests
It generates the code, runs the project, and observes the actual result—as a developer would.
Sees the error and fixes it
If something breaks, it reads the error message, adjusts the code, and tries again. This loop is what helps solve complex problems.
That’s why the feature is practically unlimited: since the output is real code, you don’t run into the limits of a closed set of blocks. If it can be programmed, it can be built.
you describe
the AI codes
test and adjust
no fixed blocks
📦 "Everything Is JSON Under the Hood"
Here’s a secret that demystifies everything: that pretty screen for dragging blocks is just a interface over code. Under the hood, the entire workflow is described in JSON — a structured text format that lists each block and each connection.
{
"gatilho": "formulario_enviado",
"passos": [
{ "acao": "transformar_dado" },
{ "acao": "salvar_registro" },
{ "acao": "enviar_email" }
]
}
In practice, you can copy a workflow from a visual tool and paste it—and what gets passed along is precisely that JSON. In other words: you were already working with “code” without realizing it. That takes away the fear of going down a layer and working closer to the foundation.
🔍 Try it
In a no-code tool, copy a scenario and paste it into a text editor. You’ll see the structure in JSON. You don’t need to understand every line — just notice that "code" is simply organized text.
the nice-looking screen
the text behind it
you see the structure
less fear
🎯 Which Tool for Which Problem
There is no abstractly "best" tool — there is the right for the problem. Two questions resolve almost every doubt: "does this change?" e "does it need its own screen?".
✓ Use no-code when
- ✓The task is simple and stable
- ✓The steps are always the same
- ✓Doesn’t need its own interface
- ✓Speed is more important than customization
✗ Prefer an agentic app when
- ✗The problem is complex and changes
- ✗The logic is custom and nontrivial
- ✗You need a custom screen
- ✗Full control matters more than speed
| Question | If NO | If YES |
|---|---|---|
| Does this change over time? | → no-code | → agentic app |
| Does it need its own screen? | → no-code | → agentic app |
| Is the logic complex? | → no-code | → agentic app |
the 1st question
the 2nd question
→ no-code
→ app
🧩 Why learn both
No-code and agentic building don’t compete — they complete. If you understand how a step-by-step workflow works, you can guide an agent better (you know what to ask and in what order). And if you've already built an app, you have a better sense of when a simple workflow is enough.
✓ Knowing no-code helps with agentic
- ✓You think in clear steps
- ✓Describe the goal more precisely
- ✓Recognizes triggers and actions
✓ Knowing agentic helps with no-code
- ✓You see the limits of the fixed workflow
- ✓Knows when to "raise the bar"
- ✓Doesn’t force an app where one isn’t needed
🔌 They also connect
The two worlds communicate via MCP (a standard that connects tools and agents). An app you built can be triggered by a no-code workflow—and vice versa. A broader toolkit means more solutions at your disposal.
don’t compete
thinks in stages
more solutions
integration
🏠 IKEA vs. Building from Scratch
An analogy brings the idea together: the cloud vibe coders (platforms that build and host for you) are like a IKEA house. They're ready to use and quick to set up—but they have fixed structures. Building in local environment is building the house however you want, wall by wall.
🏠 IKEA Home (Cloud)
- +Ready to go and fast — starts in minutes
- +No need to manage the foundation
- −Fixed structures — you can only change so much
- −You depend on the platform
🧱 Build from scratch (local)
- +Full control — any plant is possible
- +The code is yours and stays on your machine
- −Requires more from the builder (you + the AI)
- −Less "ready-made"
⚖️ The trade-off in one sentence
Convenience on one side, control on the other. There’s no one right answer: start with IKEA when you want speed; go local when you hit the limits of fixed structures.
ready-to-use cloud
free space
speed
total freedom
🔬 Practical example
The same idea — "notify me when a price drops" — it can live in different layers, depending on what you want to deliver:
- 1.Just notify? "Checked the price → sent a message." Fixed steps → no-code solve.
- 2.Want a dashboard with login, history, and charts? This is its own screen with its own logic → local app (agentic).
Notice: the idea doesn’t determine the tool — the level of complexity and whether you need a custom interface do.
🏋️ Exercise
Get a automation you would build in Make (something simple and fixed) and describe it as a agentic app would do differently. For each version, answer:
- What the app wins compared with the no-code workflow (screen, history, flexibility)?
- What it costs more (build time, maintenance, complexity)?
- In the end: is it worth moving up a layer, or is the simple workflow enough?
This exercise trains you to choose the right tool before you start building.
⚡ Ready-made prompts
Copy, paste into your AI assistant, and adapt to your use case.
Compare como "[tarefa]" seria feita como fluxo no-code (Make/n8n) vs. como app agentic (um IDE com agentes de IA). Liste prós e contras de cada abordagem em tópicos curtos e termine recomendando qual usar e por quê.
Sou iniciante. Explique, com uma analogia simples, a diferença entre automação determinística (passos fixos, tipo Make/n8n) e construção agentic (a IA escreve e corrige o código). Use o contexto de "[meu negócio]".
✅ Module summary
Next module:
1.3 — Complete environment setup