The promise of Drag‑and‑Drop AI
Low code has entered the AI agent builder scene in the form of Copilot Studio (not to be confused with the other five things named Copilot at Microsoft). The promise is enticing:
“build powerful agents without writing a single line of code. Just drag, drop, and deploy”
To be fair, this approach has its place. Just look at the success of PowerApps. For internal tools, like a quick app to track vacation requests or automate a simple approval chain, it is fantastic. It empowers employees to solve their own immediate problems in a self-service way without waiting six months for IT to wake up.
We believe there is a similar space for simple, self-service agents that handle basic tasks.
When complexity breaks the low‑code promise
The use cases we tackle at Ada (often for Proximus) rarely fall under “basic”. And that is where the low-code dream often hits a very hard, very concrete wall.
The analogy can be made to the early days of the web. WYSIWYG website builders were great if you needed a brochure site for a local bakery. But they never caught up to code-based development for complex platforms.
Why? Because the moment you needed to do something unique, something the “widget” didn’t support, you were stuck.
On the surface, a tool like Copilot Studio looks slick. But in the real world of huge organizations like Proximus, integration is never standard. The systems we need to talk to at Proximus don’t expose clean, public APIs that fit into a pre-built “connector.” They often run on custom middleware, legacy hubs, or highly specific internal logic. These agents need tailored tools that restrict permissions and limit their scope.
When you try to force a low-code tool to handle that, the “no-code” efficiency vanishes. You end up trying to hack complex logic into tiny text boxes inside a rigid UI, with no version control and no way to debug it properly. You haven’t avoided coding; you’ve just forced yourself to code in a terrible environment.
The future: building code without writing code
That is why we choose to specialize in pro-code agent frameworks (like LangGraph) that can build an agent in a complex environment from development to production.
We don’t choose code because we want to be gatekeepers. We choose it because code is the ultimate flexibility. When we treat agents as code:
- We can handle the weird edge cases.
- We can connect to that customized API that hasn’t been updated since 2015.
- We can run automated tests to ensure the agent doesn’t hallucinate before we merge the PR.
This doesn’t mean the door is closed for non-developers. Quite the opposite. We’re moving away from the idea that “low code” means “drag and drop.” It has never been easier to build code without writing code, “vibe coding” is here and whether you like it or not, it’s here to stay.
Soon, non-developers won’t need a restrictive UI to build an agent. They will use natural language to tell an AI what they want, and the AI will write the actual code for them.
You get the ease of use of a low-code platform, but the output is robust, standard code that engineers can actually maintain, test, and scale.
Conclusion
There is absolutely a place for low-code tools: they are the perfect sandbox for prototyping and simple internal tasks. But when you are ready to move from a sandbox to a skyline, you need structural integrity.
Don’t build a mission-critical monster just because the drag-and-drop interface makes it look easy. Let’s build something scalable, testable, and maintainable, together.
This is the second item in a series of opinion pieces on the broader technology landscape around AI and its impact on Proximus. You can find the first item here.
Jan
Tech Lead
Proximus Ada