Every major advance in software development has given developers a little more leverage. Higher-level programming languages, reusable components, visual designers, and low-code platforms have all helped us build increasingly sophisticated applications without having to reinvent everything from scratch.

Now, AI-powered coding agents are changing the equation again. And somewhat ironically, they're bringing code back into the spotlight at a time when low-code platforms have spent years trying to minimize it.

Some see this as a sign that low-code platforms are becoming obsolete. I see it differently. In this article, we'll explore how AI-powered development is changing the rules of abstraction and why combining coding agents with mature low-code platforms may finally give us the best of both worlds: the flexibility of traditional programming and the productivity and enterprise capabilities of low-code development.

Standing on the Shoulders of Giants

If you look back at the history of computer science, much of the progress we've made in software development can be traced to the introduction of better, more expressive abstractions. Each new generation of tools has allowed developers to work at a higher level, focusing more on what they're trying to accomplish and less on the underlying mechanics of making it happen.

Early programmers worked directly with machine instructions expressed as ones and zeroes. Assembly language made things a little more manageable by introducing symbolic instructions. Higher-level languages like C allowed developers to express increasingly complex logic in something resembling human-readable form. Object-oriented languages like C++ and Java took things even further, making it easier to organize software into reusable objects and components.

From there, component-based development frameworks, fourth-generation languages (4GLs), and rapid application development (RAD) tools continued to raise the bar. Developers could increasingly assemble applications from reusable building blocks, much like putting together a LEGO™ set, rather than writing every piece of functionality from scratch.

Figure 1: The Evolution of Programming Abstractions

Steve Jobs famously described computers as a "bicycle for the mind." I've always liked that analogy because it captures what these abstractions have done for software developers. Each generation has given us a better bicycle, allowing us to go further and faster while expending fewer calories.

Low-code development platforms are a natural extension of this evolution. While the term low-code was (re)popularized by Forrester in 2014, many of the underlying concepts for rapid application development tools have been around for decades. What changed was how these ideas came together in increasingly sophisticated platforms that made it possible to build and deploy enterprise applications with remarkable speed.

And that's an important distinction. Despite the name, the real value of low-code development was never simply about writing less code. It was about raising the level of abstraction so developers could accomplish more with less effort.

The Low-Code Productivity Bargain

The emergence of modern low-code development platforms brought many of these ideas together under one roof. Instead of starting with a blank code editor, developers could use visual designers to assemble user interfaces, configure business logic, connect to enterprise systems, and automate workflows. Add in reusable components, cloud infrastructure, and built-in security and governance capabilities, and you had a pretty compelling environment for building business applications.

Figure 2: Working with the Power Apps Form Designer Tool

But there was a catch. These platforms were, and largely still are, highly opinionated about how applications should be built.

On the surface, that’s not necessarily a bad thing. Building development tools capable of translating virtually any business requirement into working software was an incredibly difficult and expensive undertaking. So, platform vendors focused on the kinds of applications businesses commonly needed and created frameworks optimized for building them. Standard controls, predefined layouts, declarative logic, and visual workflow designers made it possible to assemble solutions quickly without having to worry about much of the underlying implementation.

As long as your requirements fit within those boundaries, the productivity gains could be substantial. But when you needed something more sophisticated, perhaps a highly customized or consumer grade user experience, complex business logic, or an unusual integration, things could get complicated. Most platforms provided escape hatches for custom code and extensions, but using them often meant giving up some of the simplicity that made the platform attractive in the first place.

That was the low-code productivity bargain. You accepted some constraints on how applications could be built in exchange for the ability to build them much faster.

For many enterprise applications, that was a trade worth making. And it still is in many instances. But with AI-powered coding agents entering the picture, we no longer have to make quite so many compromises.

AI Changes The Rules of Abstraction

Large language models (LLMs) have introduced an entirely new way for developers to express what they want to build. Rather than working within the confines of a visual designer or translating requirements into code by hand, developers can increasingly describe what they want in natural language and have AI generate the underlying implementation.

Of course, generating code from natural language is only part of the story. Early AI coding assistants were useful for completing functions, generating boilerplate code, and answering programming questions. But the emergence of agentic development tools like GitHub Copilot, Claude Code, and OpenAI Codex has taken things much further.

By surrounding LLMs with the right context, tools, and instructions (often referred to as an agent harness), these coding agents can work across entire codebases, understand project structures, modify multiple files, run tests, diagnose errors, and iteratively refine their solutions. They're increasingly capable of carrying out complex development tasks that previously required substantial hands-on effort.

Getting back to our earlier conversation about programming abstractions, developers have historically had to learn how to express their intent through whatever language, framework, or visual development environment a platform provided. Now, AI-powered development tools are beginning to turn that relationship around, adapting to how developers express their ideas rather than requiring developers to adapt to the tools.

And unlike traditional visual designer tools, coding agents aren't inherently limited to a predefined collection of controls, templates, or workflows. They can work with established programming languages, frameworks, and component libraries to build solutions tailored to the requirements at hand.

The Accidental Development Tools Business

There's another side to this that's worth considering. Building and maintaining sophisticated graphical development tools has always been an expensive proposition. Vendors could spend years developing visual designers, component frameworks, and proprietary runtimes, only to find themselves playing catch-up as web technologies, browser standards, and user expectations continued to evolve. These tools could become surprisingly brittle over time, particularly when their underlying architectures weren't designed to accommodate newer technologies.

Compounding the problem, many of the companies building these tools weren't really in the development tools business to begin with. ERP, CRM, and SaaS vendors often introduced proprietary development environments to help customers extend and customize their core products. But building world-class developer tooling wasn't necessarily their specialty, nor was continually modernizing those tools always a priority. In closed, proprietary ecosystems, customers had few alternatives when the tooling fell behind.

AI-powered coding agents offer a potentially different path. Rather than continually reinventing the development environment, vendors can build on the capabilities of tools like GitHub Copilot, Claude Code, and Codex, allowing developers to work with modern languages, frameworks, and development practices while the platform provides the services needed to integrate those applications into the broader enterprise environment.

Changing Up the Development Economics (Again)

This changes the economics of application development considerably. Rather than investing years building increasingly sophisticated graphical tools to accommodate every possible development scenario, platform vendors can begin integrating AI coding agents into their development experiences, giving developers far greater flexibility without sacrificing the productivity gains that made low-code attractive in the first place.

In a somewhat ironic twist, the next major leap in low-code development may come from making it easier to generate more code, rather than finding new ways to avoid writing it.

Breaking Out of the Low-Code Box

We're already starting to see this shift play out in the market. Microsoft, for example, has introduced Power Apps code apps, giving developers a way to build applications using familiar web technologies like React, TypeScript, and modern UI component libraries while still taking advantage of the broader Power Platform ecosystem.

For developers who've spent years working within the confines of traditional low-code designers, this opens up some interesting possibilities. Instead of assembling interfaces from a prescribed set of controls and working around the limitations of a visual designer, they can build highly customized experiences using the same frameworks and techniques employed in modern consumer applications. And with AI-powered coding agents doing much of the heavy lifting, the effort required to build those experiences can be dramatically reduced.

Think about a field service application, for example. A traditional low-code implementation might consist of a series of forms, dropdowns, and screens for looking up equipment, recording service activities, and updating work orders. Perfectly functional, but perhaps not the most intuitive experience for a technician working in the field.

Now imagine an application designed specifically around how that technician works. Interactive equipment diagrams, contextual service histories, custom navigation, and workflows that bring together information from multiple enterprise systems in a single, cohesive experience. None of these capabilities are particularly new, but building them traditionally required considerable custom development effort. AI-powered coding agents are making that level of customization practical for a much broader range of business applications.

Figure 3: Leveling Up Low-Code User Experiences With AI-Assisted Development

And the opportunity extends well beyond user interfaces. Developers can use these tools to implement sophisticated business logic, build custom integrations, create reusable components, and automate complex workflows without being confined to the patterns anticipated by a platform's designers.

What's especially interesting is that this doesn't require abandoning the low-code platform. With approaches like Power Apps code apps, developers can combine the flexibility of modern, code-first development with supported platform services and integrations.

For organizations looking to extend their ERP, CRM, and other core business systems, that combination opens the door to a new generation of highly tailored applications that would previously have been difficult to justify from a cost perspective.

You Still Need a Platform

You Still Need a Platform

If you've been following the conversation around AI-powered development lately, you've probably noticed no shortage of articles declaring the death of low-code platforms. Now that AI coding agents can generate entire applications from natural-language prompts, the argument goes, why bother with low-code at all? Just vibe code everything.

It's a familiar, if not predictable, reaction whenever a new disruptive technology comes along. Suddenly, everything that came before it is obsolete. But I think this knee-jerk reaction misses something important: there's a lot more to enterprise application development than generating code.

Building a functional application is one thing. Deploying it into an enterprise environment, integrating it with existing systems, securing sensitive data, managing access, and keeping everything running over time is another matter entirely. These are challenges that low-code platforms have spent years addressing, often through capabilities that developers would otherwise have to assemble and maintain themselves.

Figure 4: The Benefits of Building on Low-Code Development Platforms

Consider everything that surrounds a typical enterprise application: identity and access management, connectors to ERP and CRM systems, data protection policies, environment management, deployment pipelines, monitoring, and governance. None of these capabilities makes for a particularly exciting demo, but they're essential when an application moves beyond a prototype and becomes something the business depends on.

And while AI coding agents can certainly help developers implement these capabilities from scratch, that doesn't necessarily make it a good use of their time. Why recreate infrastructure that's already available, particularly when doing so introduces additional security risks, maintenance responsibilities, and operational costs?

This is where I think some of the predictions about the demise of low-code platforms miss the mark. AI-powered coding agents may reduce the value of proprietary visual development environments, but they arguably increase the value of the enterprise services and infrastructure underneath them.

We're beginning to see a model emerge where developers have much greater freedom in how they build applications while continuing to rely on the platform for the capabilities needed to deploy and operate them responsibly. Of course, those benefits aren't automatic. Developers still need to understand which platform services are available, how to integrate with them, and where custom code introduces additional responsibilities.

For enterprise IT organizations, that's a pretty compelling combination. You get much of the flexibility of traditional software development without having to start from scratch on everything surrounding the application. And as AI continues to improve the development experience, the platform itself may become even more valuable, not less.

Better Tools Still Need Skilled Developers

There's another piece of this puzzle that's easy to overlook in all the excitement around AI-powered development: the people building the applications.

If you've spent any time experimenting with modern coding agents, you've probably been impressed by how quickly they can turn a simple prompt into a working application. It's remarkable technology, and it's easy to see why there's so much enthusiasm around the idea that anyone can now become a software developer.

But there's a pretty big gap between getting an application to work and engineering something a business can depend on. AI coding agents can generate thousands of lines of code in minutes, but they can just as easily introduce security vulnerabilities, poor architectural decisions, unnecessary complexity, and technical debt that someone will eventually have to sort out. And the more sophisticated the application, the harder those problems can be to recognize.

That's why I wouldn't recommend turning inexperienced developers loose with these tools on business-critical applications. They still need to understand the fundamentals of software engineering, how enterprise systems fit together, and how to recognize when an AI-generated solution is heading in the wrong direction. Having an agent write the code doesn't eliminate the need to understand what that code is doing.

For experienced development teams, though, the opportunity is tremendous. Developers who understand architecture, integration patterns, security, testing, and user experience can use coding agents to accelerate the implementation work while spending more of their time on the decisions that actually require their expertise.

We're already seeing how this changes the way we approach custom application development at Bowdark. Our developers, architects, and designers can focus more attention on understanding business processes, designing better user experiences, and solving the problems that make each customer's environment unique, while AI helps reduce the time spent on repetitive development tasks. At the end of the day, this leads to dramatic cost savings and economies of scale.

Closing Thoughts

I think we're entering an interesting period for enterprise application development. AI-powered coding agents are giving developers considerably more freedom in how they build software, while mature low-code platforms provide much of the infrastructure needed to deploy and operate those applications at scale.

For those of us building solutions around ERP, CRM, and other enterprise systems, this changes the kinds of projects we can realistically take on. That highly customized field service application, customer portal, or specialized operational workflow that once seemed too expensive to justify may now be well within reach.

Rather than abandoning low-code platforms in favor of AI-generated applications, I'd argue that we should be looking for ways to bring these technologies together. We've spent years investing in enterprise platforms that solve some genuinely difficult problems. It would be a shame to throw all that away just because we've found a better way to write code.

And perhaps that's the most interesting part of this whole shift. After spending decades trying to make software development more productive by writing less code, we may finally get there by making it easier to write as much code as we need.