Low-code platforms originally promised something highly attractive: faster software delivery, less dependence on developers, and a way for business users to participate more directly in building systems. Their real strength was not just speed, but accessibility. Logic became visible, workflows could be followed step by step, and behavior was represented in a way that was easier to understand than traditional code.
That promise still matters, but the way low-code is used is changing. With AI now part of the development process, these platforms are evolving into something different from what they were originally designed to be.
The Original Promise of Low-Code
Traditional low-code platforms were built around visual construction. Users assembled flows, connected systems, added rules, and defined behavior through diagrams and configurable steps. The visual model was not merely documentation layered on top of the system; in many cases, it was the system.
This was what made low-code appealing beyond engineering teams. Business users could inspect workflows, follow the logic, and sometimes even modify parts of the implementation themselves. The platform lowered technical barriers by making system behavior visible.
How AI Changes the Way Low-Code Is Used
Once AI enters the picture, that model begins to shift. Instead of manually building logic step by step, users increasingly describe what they want in natural language. AI then generates the implementation, often in the form of scripts, functions, or code blocks, which are inserted into the platform.
The visual flow may still be present, but it no longer contains the full logic of the system. What the user sees is often just the outer structure. The real behavior increasingly lives inside generated code.
This is a meaningful change because it alters the role of the platform itself. What was originally a visual environment for defining logic becomes, in practice, an environment for hosting and coordinating logic that has been created elsewhere.
The Problem: Accessibility Declines While Complexity Becomes Less Visible
This is where the current use of low-code and AI creates tension. AI makes it much easier to produce sophisticated behavior, but that behavior often ends up in places that are not accessible to non-technical users. The workflow still looks clean and understandable, yet the actual decisions, transformations, and conditions are hidden inside code nodes or custom functions.
As a result, complexity has not been removed. It has simply been relocated.
That relocation matters because it weakens one of the original promises of low-code. Business users may still be able to follow the high-level flow, but they can no longer fully understand what the system is doing without reading code. The interface remains visual, while the source of truth moves into implementation details that many users cannot inspect or validate.
In that sense, AI-assisted low-code creates a paradox: it increases speed and flexibility, but at the same time reduces transparency.
A Better Description: Function-as-a-Service with a Visual Explanation Layer
Once the core behavior of a system lives inside functions, calling the platform simply “low-code” becomes less precise. Architecturally, it starts to look much closer to a function-as-a-service environment.
The logic is packaged into callable units. The platform executes and orchestrates them, connects them to surrounding systems, and provides the operational layer needed to run them reliably. The visible diagram remains useful, but its purpose changes. It no longer defines the system. Instead, it represents a system whose real behavior is determined by the underlying functions.
This distinction is important because it clarifies what the visual layer is becoming. It is not disappearing, but it is no longer the primary place where logic is authored. Its role is increasingly to explain, expose, and validate what the functions are doing in a form that humans can understand.
The Next Step: From Manual Flow Building to Intent-Driven Systems
Current platforms often combine two ideas that no longer fit together perfectly. On the one hand, the logic is increasingly generated by AI. On the other hand, users are still often expected to manually place nodes, connect steps, and shape the workflow themselves.
That inconsistency is not the destination. The more coherent model is already visible. In that model, users do not build flows step by step. Instead, they describe their intent. AI translates that intent into the underlying logic, and the platform derives the corresponding structure and flow diagram from that implementation.
This creates a different relationship between user, AI, and platform. The user works at the level of goals and expected outcomes. AI generates or modifies the code. The platform executes that logic and renders it back as a flow that the user can review and validate. When the user wants to make a change, the primary action is no longer rearranging nodes by hand. The user refines the intent, AI updates the implementation, and the platform updates the representation.
In this model, the flow diagram remains valuable, but not because it is the primary authoring surface. Its value lies in making the generated system understandable.
What This Means for Platforms
Platforms will need to evolve beyond the original low-code model. Execution, orchestration, integration, and governance will remain essential, but they will no longer be enough on their own.
They will also need to support deep AI integration in the creation and modification of logic. Just as importantly, they will need to continuously translate that logic into a representation that users can inspect, understand, and validate. That means the platform is no longer just a visual builder, and not just a runtime either. It becomes the layer that connects user intent, generated code, system execution, and human-readable explanation.
Conclusion
Low-code is not disappearing, but it is changing in a fundamental way. The most useful description is no longer visual development with optional code. It is increasingly an AI-assisted, function-based model in which logic is generated as code, executed by the platform, and represented back to the user as a flow that can be reviewed and refined.
This is where platforms need to move: toward a model where users express intent, AI builds the underlying logic, and the platform makes that logic operational and understandable.
Note
This article builds on an original German blog post and further develops its central idea for the Maranics audience.
Original version: https://itc-willmer.de/blog/Low-Code-war-gestern
