When Software Is Commoditised, What Is the Value of Low-Code/No-Code?

A functional SaaS product used to take three months and $50,000 to build. In 2026, a solo founder can ship one over a weekend for the cost of an API subscription.

AI coding assistants like Claude Code, Cursor, and GitHub Copilot have made the act of writing software radically cheaper. 41% of all code is now AI generated or AI assisted. 25% of current Y Combinator companies have LLMs writing 95% of their code.

Software creation is becoming a commodity. Multiple tools can deliver the same output. The cost is approaching zero. The differentiation from simply "having built something" is shrinking fast.

This raises an awkward question for the low-code and no-code industry. These platforms were built on a specific promise: you don't need to know how to code. But AI coding assistants now deliver the same promise, with more flexibility and no platform constraints. So what role remains for low-code and no-code?

What "Commoditised Software" Actually Means

Commoditisation happens when multiple suppliers can deliver the same output. The product becomes interchangeable and the price drops. In software, this means the act of building something is no longer a competitive advantage.

AI coding assistants are the main driver. Open source ecosystems accelerate it further by turning proprietary innovations into freely available building blocks. Together, they have made software creation faster, cheaper, and more accessible than ever.

Andrej Karpathy has been tracking this shift since 2017, when he wrote that "Software 2.0 is eating software": neural networks replacing hand-written code. By June 2025, he extended the idea to Software 3.0: LLMs eating both traditional code and classical ML.

The pace reflects this. Karpathy coined "vibe coding" in February 2025 to describe prompting AI and accepting whatever comes back. By February 2026, he had already declared it "passe" and moved on to "agentic engineering", where developers orchestrate AI agents rather than writing code directly.

Each layer of software consumes the one below it. Or as Sequoia put it: "We're watching software eat the software that eats software."

The Original Promise of Low-Code/No-Code

The low-code/no-code movement was built on a clear value proposition: let people build software without writing code.

Drag and drop interfaces. Visual workflows. Pre-built components. The goal was to remove the developer bottleneck and put creation in the hands of business users.

The market responded. Gartner projects the low-code market will reach $44.5 billion by 2026, growing at roughly 19% per year. They predict 75% of new applications will use low-code technologies. 84% of enterprises have already adopted low-code or no-code tools.

Platforms like Bubble, Retool, Webflow, and Airtable became go-to solutions for everything from internal tools to customer facing products. Gartner expects citizen developers to outnumber professional developers 4:1 by 2026.

The numbers suggest a thriving industry. But here is the problem.

AI Delivers the Same Promise, But Differently

Low-code platforms and AI coding assistants solve the same fundamental problem: making software creation accessible to more people.

The difference is in the output.

Low-code platforms abstract code behind visual interfaces and proprietary runtimes. Your application lives on someone else's platform, built with someone else's building blocks, locked into someone else's ecosystem.

AI coding assistants write real code in standard programming languages. The output is portable. It runs anywhere. You own it completely.

Both are abstractions. But AI's abstraction maps to standard output that any developer can read, modify, and deploy. Low-code's abstraction maps to proprietary systems that often cannot be migrated without rebuilding from scratch.

This portability difference matters. 62% of IT decision-makers express concern about vendor lock-in with low-code platforms.

The speed advantage is also shifting. AI coding tools keep getting faster. What took a team of consultants weeks can now be done in hours. The barriers that made low-code attractive, the cost and time of traditional development, are being erased by a different technology entirely.

As one analyst framed it: "Where low-code's value was in hiding the code, AI's value is in writing it. The abstraction layer, once essential, is becoming less critical."

Where Low-Code/No-Code Still Wins

Despite all of this, low-code/no-code is not dead. There are areas where it still has a genuine edge.

Governance, Security, and Compliance

Low-code platforms come with built-in audit trails, access controls, and policy enforcement. For regulated industries like finance, healthcare, and government, these guardrails are not optional.

AI generated code can be excellent, but it does not come with an enterprise governance layer out of the box. Someone still needs to set up the infrastructure, security reviews, and compliance checks. Mature low-code/no-code platforms have spent years building this.

As TechRadar reported, low-code platforms are becoming "the perfect complement, creating structured environments for the secure integration of AI generated code."

The strongest remaining case for low-code/no-code may be the least glamorous one: governance is a durable moat.

The Orphan Code Problem

AI can write code. But can the person who prompted it maintain it?

Miguel Baltazar, VP of OutSystems, compared the situation to "trying to write a book in Japanese with an AI." You get output you cannot read, debug, or evolve on your own.

The result is what some call "orphan code": software that nobody fully understands. Arcjet CEO David Mytton warned that vibe coded systems become a source of technical debt through "random library choices, convenient defaults, inconsistent naming, odd architecture, and the kind of glue code that becomes permanent purely because nobody wants to touch it again."

Low-code/no-code platforms avoid this problem by constraining how applications are built. The trade off is flexibility, but for teams without strong technical leadership, that constraint is a feature, not a bug.

Speed for Well-Understood Patterns

For internal tools, approval workflows, dashboards, and simple CRMs, mature low-code/no-code platforms are still incredibly fast. These are solved problems. The templates, connectors, and components have been refined for years.

Need a meeting summarizer that records, transcribes, and emails notes? Minutes on Zapier or Make. Need lead routing that assigns form submissions to the right rep? Also minutes.

These use cases don’t benefit from custom code. They benefit from pre-built integrations and tested workflows.

When the use case aligns with the platform, nothing beats the speed of clicking together ready-made components.

Genuine Non-Technical Accessibility

AI coding tools have lowered the bar, but they have not eliminated it. You still need some comfort with technical concepts to effectively prompt an AI, review its output, and debug when things go wrong.

Low-code platforms with visual interfaces remain more accessible to true non-technical users. A marketing manager building a simple workflow in Airtable or a landing page in Webflow does not need to think about code at all.

The US faces a 1.2 million developer shortage by 2026. Low-code/no-code platforms help fill that gap by genuinely letting non-developers participate in software creation.

Where Low-Code/No-Code Is Losing Ground

The advantages above are real. But they are narrowing.

Vendor Lock-In Is the Original Sin

This is the foundational weakness. Your application, your data, your business logic, all living on a platform you do not control.

Migration often means rebuilding from scratch. Pricing changes, feature removals, or platform shutdowns can hold your business hostage. AI generated code in standard languages has none of these constraints. You can host it anywhere, modify it freely, and switch providers without starting over.

The Abstraction Is Becoming Unnecessary

Low-code's core innovation was removing the need to write code. If AI writes the code for you in a real language, the proprietary visual layer becomes an extra step rather than a shortcut.

Why learn Bubble's workflow editor when you can describe what you want in plain English and get working Python or JavaScript?

The low-code/no-code vendors see this too. Every major platform has now bolted on generative AI features. One industry VP declared that "citizen developers can build working apps with nothing more than a conversation." If that is true, the visual builder layer becomes unnecessary.

Learning Curves Are Comparable

This one surprises people. Bubble reportedly takes 3 months for basics and 6 to 12 months for proficiency. That is comparable to learning to prompt an AI coding tool effectively.

The argument that low-code/no-code is "easier" holds up for simple use cases. But the moment you need anything beyond the basics, the learning investment is significant either way.

Agentic AI Exposes the Ceiling Fast

Anyone who has tried building agentic AI applications on a low-code/no-code platform knows the pattern. The first demo looks great. The second iteration hits a wall.

Agentic AI requires fine-grained control over things like state management, multi-agent orchestration, memory handling, tool use, and prompt design. These are exactly the things low-code/no-code abstractions hide from you.

Flowise is a good example. Developers praise it for sketching agentic ideas visually, but as teams push toward production, the canvas becomes visual clutter, debugging tools feel underpowered, and writing custom code nodes becomes unavoidable. Its multi-agent system only supports a single supervisor. Try to delegate tasks in parallel and the system breaks.

The same story plays out across the category. Zapier Agents offer no native evaluations or versioning for agent iterations. n8n is acknowledged as limited for multi-agent orchestration, memory handling, and long-running autonomy. Most visual builders lack native streaming support for LLM responses entirely.

As Barry O'Reilly put it: "When we tried to scale these solutions, their limitations became glaring." Not every problem can be solved by stitching together pre-built components.

Code-based frameworks like LangGraph and CrewAI exist specifically because agentic AI demands control that visual builders actively remove. They let you manage state deltas between nodes, implement custom memory stores, and orchestrate multiple agents in parallel. Low-code/no-code platforms were not designed for this level of complexity, and bolting it on after the fact rarely works.

The irony is sharp. Low-code/no-code platforms are racing to add AI features while simultaneously being the wrong tool for building the most important category of AI applications.

This does not mean these platforms have no role in agentic AI. The mistake will be trying to use them to build agents. The opportunity is using them to serve agents. That distinction changes everything. It shifts their position in the stack from the intelligence layer to the execution layer.

The Paradox: Growing Market, Shrinking Moat

Here is what makes this interesting. The low-code/no-code market is growing at 19% annually while the fundamental need it addresses is being solved by a different technology.

Growth and obsolescence can coexist.

We have seen this before. The fax machine market grew well into the 2000s even as email made faxing increasingly unnecessary. Feature phone sales kept rising even after the iPhone launched. Incumbents can grow on momentum while the ground shifts beneath them.

The low-code/no-code platforms that survive will likely look very different from what they started as. DEVOPSdigest reports that traditional drag-and-drop visual builders are "already on the decline." The platforms absorbing AI capabilities may endure, but they will be less "no-code visual builder" and more "AI-powered application platform." At that point, the distinction between low-code and AI coding starts to blur.

The Pro-Code and Low-Code/No-Code Play

The framing so far makes it seem like a binary choice: low-code/no-code or pro-code. But the more interesting future is not one replacing the other. It is one where they operate together.

The pattern looks like this: business users design and own workflows on low-code/no-code platforms, while pro-code agents decide when and how those workflows get triggered.

Take n8n as an example. A business team can build a workflow that enriches inbound leads, scores them, and routes them to the right sales rep. They control the rules. They iterate quickly. They understand the domain better than any engineer.

On the other side, a developer builds a supervisor agent in Python or TypeScript. That agent handles reasoning, planning, and context across systems. When it determines that a lead needs processing, it calls the appropriate n8n workflow.

The bridge between these layers is MCP (Model Context Protocol). Workflows can be exposed as MCP tools that compatible AI agents can discover and invoke. The business user does not need to understand how the agent reasons. The developer does not need to encode lead-scoring logic. Each side focuses on what it understands best.

This is not hypothetical. n8n's MCP Server Trigger node already does this. Business users connect tool nodes to it, and external AI agents can discover and execute those tools at runtime. The protocol handles the contract between both sides.

Instead of competing, low-code/no-code and pro-code form a layered system: deterministic execution owned by the business, intelligent orchestration owned by developers.

Why This Matters for Enterprise

I wrote about what it takes to build end-to-end agentic AI in the enterprise. One of the central arguments: the bottleneck is not the model or the framework. It is the process knowledge that sits across multiple teams and has never been documented in one place.

The pro-code and low-code/no-code split directly addresses this. Business teams hold the process knowledge. They encode it in low-code/no-code workflows they can see, modify, and reason about. Technical teams build the orchestration layer that ties those workflows into larger agent systems.

That only works if the two groups have clear boundaries. Low-code/no-code for business logic. Pro-code for orchestration. MCP as the interface between them.

theCUBE Research calls this the rise of the "Orchestrator Developer": someone who sits between business users and traditional developers, combining business judgment with technical fluency. Their job is not writing code from scratch. It is wiring together the right pieces and making sure the system holds.

What This Means Going Forward

Low-code/no-code is not dead. But its role is changing.

The original pitch of "you don't need to write code" is the weakest case. AI delivers that same promise with more flexibility, more portability, and fewer lock-in risks.

The governance case remains strong. Regulated enterprises that need guardrails, audit trails, and controlled environments will continue to find value in mature platforms that provide these out of the box.

But the most compelling case is the one emerging now: low-code/no-code as the layer where business users encode their logic, and pro-code agents consume it. Not competing with AI. Complementing it. Business teams own the workflows. Technical teams own the orchestration. Standard protocols like MCP hold the two together.

If you are evaluating where low-code/no-code fits in your stack today, here is a starting point:

Know where low-code/no-code stops working for you. If you need fine-grained control, custom integrations, or complex logic that the visual builder was not designed for, a pro-code solution will serve you better. Keep low-code/no-code for self-contained business logic where it excels.
Pick one workflow and expose it via MCP. Start small. Take an existing n8n or Make workflow and make it callable by an external agent. See how the handoff feels in practice.
Draw the boundary between business logic and orchestration. If a business user owns the rules, it belongs in low-code/no-code. If it requires reasoning, planning, or cross-system coordination, it belongs in code. Make that line explicit for your team.

The platforms that thrive will not be the ones that try to do everything visually. They will be the ones that make business knowledge and executable workflows accessible to agents. The question is not "low-code/no-code or pro-code." It is "what does each one own?"