Don't learn n8n in 2026 - do THIS instead

One Sentence Summary

NADN is obsolete; agentic coding tools like Claude Code and Codeex unlock superior automation for non-tech and pro developers today.

Main Points

NADN promised complex workflows but delivered fragile, hard-to-debug sandboxes.
In the past, learning to code offered unlimited long-term potential over NADN's quick start.
Today agentic coding tools outperform NADN for non-technical users.
Cloud Code enables natural-language website scraping and API data retrieval.
Agentic tools can code and debug via error messages without full understanding.
NADN is slow and spaghetti-like; agentic tools offer clearer, more maintainable logic.
Claims that agentic tools optimize JSON are false; they excel at code, not JSON gymnastics.
Recommendation: learn Python basics from “How to Automate the Boring Stuff with Python.”
Then leverage agentic coding for day-one productivity and scalable growth.
Tools (e.g., Claude Code, Codeex) unlock end-to-end automations with minimal friction.

Takeaways

Stop investing in NADN; switch to agentic coding now.
Learn Python for 10–20 hours to boost tool effectiveness.
Use Claude Code or Codeex to start building real automations.
Expect continuous improvement via plugins, models, and new workflows.
Build foundational skills (TypeScript, CI/CD, environment management) for professional scale.

SUMMARY

Anik argues learning n8n/Make/Zapier in 2026 is a dead end; agentic coding tools like Codex/Claude Code plus minimal Python yield faster, scalable automations.

IDEAS

Low-code workflow builders promise complexity, but collapse into fragile spaghetti once tasks become non-trivial fast.
Dragging nodes to mimic loops wastes hours versus coding constructs written in seconds with scripts.
Browser-based workflow UIs crash under complexity, making serious automations painful to build and maintain.
Debugging low-code failures is hard because errors are vague and models can’t inspect the workflow well.
Influencers sell impressive diagrams without receipts, hiding fragility and lack of real business savings always.
n8n was always a short-term win with a fast ceiling, limiting long-term potential severely.
Coding historically required months of learning, but agentic coding tools erase that barrier for novices today.
Non-technical users can build scrapers, API pulls, and content pipelines by describing intent naturally now.
Agentic tools thrive when you paste error messages; you don’t need to understand them initially.
Being “dangerous enough” is the new threshold: direct agents, review outputs, and debug minimally yourself.
Outside tech hubs, people still believe low-code is cutting edge, creating a perception lag.
Agentic tools are optimized for code, not brittle JSON export formats underlying workflow engines today.
Generating complex n8n JSON via agents often breaks, with missing brackets or structural inconsistencies.
Low-code blocks access to the strongest leverage: agentic tools can’t easily reason over node spaghetti.
Learning Python briefly multiplies productivity with agents, enabling better prompts and debugging intuition quickly.
“Automate the Boring Stuff with Python” teaches practical automations aligned with business needs broadly.
Ten to twenty hours of Python can unlock disproportionate gains using Codex or Claude Code.
Impatient learners can start directly with agents, then backfill concepts as confusion appears later.
Agentic tools can teach you concepts on-demand, turning confusion into micro-lessons during building.
Professional automation work benefits from TypeScript, frontend-backend wiring, and environment variable hygiene knowledge.
Deployment familiarity matters: Vercel, Render, or Railway become essential when shipping real automations publicly.
Scaling differs: low-code scales by hiring more builders; agentic coding scales as models improve automatically.
Plugins, skills, and community configs let novices borrow senior best practices without deep expertise upfront.
Tool progress compounds: better models and harnesses increase output quality without you changing workflows much.
Low-code improvement does not compound similarly; you remain capped by the platform’s constraints long-term.
The first successful agent-built automation reframes everything, making low-code feel irrational afterward often.
He frames n8n as “dead in 2025,” replaced by accessible agentic coding tools for everyone.

INSIGHTS

The biggest moat is debuggability: code plus error logs is searchable; node graphs are opaque.
Agentic coding collapses the learning curve by turning intent into code, then code into learning.
Low-code’s ceiling is architectural: once logic branches, composition requires primitives the platform hides poorly.
Productivity now compounds with model improvements, so choosing tool ecosystems is choosing your growth curve.
“Know enough to be dangerous” replaces “learn to code fully,” shifting education toward supervision skills.
When tools can read code, maintenance becomes collaborative; when they can’t, systems rot quickly.
Influencer workflows exploit visual impressiveness, but durability is the real metric for business automations.
JSON-as-workflow is a weak abstraction for agents; languages with tests and modules remain dominant.
Minimal programming knowledge increases agent leverage more than additional low-code mastery ever could today.
Scaling with agents is primarily about evaluation and direction, not dragging more nodes or hiring more hands.
Perception lags reality; people outside dense tech communities invest in outdated paths longer than necessary.
The future skill is orchestration: prompts, testing, deployment, and review, not tool-specific clicking habits.

QUOTES

"If you're learning NAED in 2026, you are wasting your time."
"NAN was always a dead end."
"agentic coding tools like Codeex and Cloud Code have gotten so good"
"Let's talk about NAND, what it promised and what it delivered."
"your browser would crash."
"They'd be impossible to debug"
"reimplementing basic constructs like while loops, if statements, and for loops"
"The influencers who were selling NAD as a career path were always selling a dead end."
"They would never show you receipts."
"these workflows are fragile."
"Agentic coding tools have gotten so good that the barriers"
"zero reason to ever use NATM."
"You don't need to be a real programmer."
"you just need to know enough to be dangerous"
"N8N workflows are very fragile."
"building an N8N is painfully slow."
"they're not optimized to make these."
"First, I recommend you spend some time learning Python."
"How to Automate the Boring Stuff with Python."
"maybe spend 10 or 20 hours."
"NAN died in 2025."
"Open up claude code, tell it what you wanted to make, and see what happens."

HABITS

Avoid investing weeks mastering low-code tools; instead, start building automations with agentic coding immediately.
Copy and paste error messages into agents, letting them debug without you understanding details initially.
Practice describing intent clearly in natural language prompts, then refine requirements as agents iterate.
Learn enough Python basics to read scripts, spot mistakes, and direct agents confidently afterward.
Use “Automate the Boring Stuff” exercises to build real automations, not abstract tutorials ever.
Build small working scripts first, then expand scope gradually as you gain trust in workflows.
Ask agents to explain unfamiliar concepts on demand, turning building into incremental learning sessions.
Prefer code projects with tests, so outcomes become binary pass/fail signals for improvement quickly.
Deploy simple projects on Vercel, Render, or Railway early to learn shipping habits practically.
Store environment variables properly rather than hardcoding secrets, keeping automations safe for production.
Learn TypeScript basics if building frontends, enabling clearer supervision and better UI integration.
Design workflows as modular functions and services, avoiding monolithic spaghetti logic structures entirely.
Keep automation logic in version-controlled repositories, enabling rollback, review, and collaboration easily.
Validate influencer claims by demanding demos, reliability evidence, and measurable savings before believing.
Treat maintenance as a first-class cost, choosing tools that produce understandable, debuggable artifacts.
Build a personal library of scripts, reusing modules instead of recreating nodes repeatedly in tools.
Iterate by filling knowledge gaps only when they block progress, not through exhaustive upfront study.
Use agentic tools for content pipelines, specifying voice and formatting constraints for consistent output.
Prefer workflows agents can read directly, so improvements and refactors remain accessible later always.
Regularly revisit tooling choices as models improve, migrating toward systems that compound with progress.

FACTS

Speaker identifies as Anik, holding a PhD in economics from Northwestern University.
He says he worked as an ML engineer for six years and now runs AI consulting.
He frames n8n as low-code drag-and-drop workflows aimed at business automation without programming skills.
He claims complex n8n workflows can crash browsers, becoming difficult to build and maintain practically.
He argues debugging n8n is hard because errors are uninformative and workflows are opaque.
He says n8n often recreates loops and conditionals through nodes, slowing development dramatically.
He claims agentic tools like Codex and Claude Code let non-technical users build automations quickly.
He suggests copying error messages into agents often resolves issues without deep understanding from users.
He asserts agentic coding tools are optimized for code rather than generating complex workflow JSON files.
He claims generating non-trivial n8n JSON with agents often breaks due to missing structure or brackets.
He recommends learning Python via “Automate the Boring Stuff with Python” for practical automation skills.
He estimates 10–20 hours of Python study can significantly improve productivity using agentic tools.
He recommends learning TypeScript for frontend work when doing automation professionally in businesses today.
He recommends learning frontend-backend connections and environment variable management for scalable automations.
He mentions CI/CD deployment platforms like Vercel, Render, and Railway for shipping applications.
He claims scaling low-code requires hiring more builders, whereas agentic coding scales with model improvements.
He notes plugins and skills can add best practices to agentic tools without deep expertise.
He claims people outside Bay Area underestimate how widely n8n is dismissed in tech circles.
He concludes that time spent learning agentic coding yields far higher returns than learning n8n.
He claims “n8n died in 2025,” asserting agentic coding became strictly better afterward.

REFERENCES

n8n
Make
Zapier
LinkedIn
Twitter / X
YouTube
Reddit
Codex
Claude Code
Cursor
Bay Area tech bubble
Python
Web scraping
APIs
Content creation automation
Error messages for debugging
While loops
For loops
If statements
JSON documents
“How to Automate the Boring Stuff with Python”
Northwestern University
Economics PhD
ML engineer
AI consulting practice
TypeScript
Front-end development
Backend services
Environment variables
CI/CD
Vercel
Render
Railway
Claude 4.5
GPT Codex
Plugins
Skills

ONE-SENTENCE TAKEAWAY

Skip low-code ceilings; learn minimal Python and leverage agentic coding tools for compounding automation power.

RECOMMENDATIONS

Stop learning n8n workflows; instead, build your first automation using Codex or Claude Code today.
Spend ten hours with “Automate the Boring Stuff,” then immediately apply lessons with agents building scripts.
Choose tasks with clear pass/fail tests so agent iterations converge quickly and reliably every time.
When errors appear, paste the full traceback and ask the agent for a minimal fix.
Keep automations in code repos with version control, enabling rollback and collaborative review easily.
Avoid complex workflow JSON generation; prefer Python scripts or small services agents understand fully.
Learn environment variable basics early, preventing secret leaks and making deployments safer for clients.
If shipping UIs, learn TypeScript fundamentals to supervise frontend changes and integrations confidently.
Practice writing requirements clearly, adding constraints and examples to reduce agent misunderstandings quickly.
Validate automation influencers by demanding working demos and measurable business outcomes, not screenshots.
Use deployment platforms like Vercel or Railway early, learning shipping and monitoring habits practically.
Modularize logic into functions and services, avoiding monolithic spaghetti that becomes unmaintainable later.
Ask agents to teach you unfamiliar concepts inline, turning building work into learning loops continuously.
Track recurring automation patterns and convert them into templates, reusing them across client projects.
Focus on supervision skills: evaluation, testing, and direction, rather than tool-specific node memorization.
Prefer ecosystems that improve automatically as models advance, so your leverage compounds over time.
Start with scraping, API pulls, and reporting scripts, then expand toward full products gradually.
Treat maintainability as core requirement, selecting tools that are debuggable when things break later.
Build a simple CI pipeline to run tests and linting, giving agents reliable feedback signals always.
Reassess tooling quarterly, migrating away from brittle low-code toward robust, testable code systems.

Get New Posts

Follow on your preferred channel for new articles, notes, and experiments.

The Tech Pulse