With AI tools like GitHub Copilot and Cursor generating full applications from prompts, many are asking whether low-code platforms still have a place. In this post and video, I explore the full no-code to pro-code spectrum and share why I think low-code isn’t dead — it’s evolving.

Is Low Code Actually Dead?

There’s a provocative question doing the rounds in the developer community right now: Is low code dead?

If you’ve been following the rise of AI-powered development tools — GitHub Copilot, Cursor, Claude, and a host of others — it might feel like the drag-and-drop, visual-first approach to building software is on its way out. But I’d argue the reality is far more nuanced. We’re not witnessing the death of low code. We’re witnessing its transformation.

Understanding the Spectrum

To answer this properly, we need to zoom out and look at the full picture: the no-code to pro-code spectrum.

No-Code

At one end, you have no-code tools. Platforms like Webflow, Glide, or Microsoft Power Apps in its simplest form allow non-technical users — often called citizen developers — to build functional apps and automations without writing a single line of code. The promise here is speed and accessibility. Anyone with a good idea can ship something.

The catch? No-code hits a wall fast. As soon as your requirements get complex — custom logic, intricate integrations, performance at scale — you’re fighting against your platform rather than being empowered by it.

Low-Code

Step along the spectrum and you reach low-code. This is where platforms like Power Automate, Power Apps, and Logic Apps live. You get visual interfaces and pre-built connectors, but the door is open for custom expressions, code snippets, and developer extensibility.

Low-code is where I spend a lot of my time, and honestly? It’s incredibly powerful when used right. You can build production-grade solutions rapidly. But it’s also where technical debt can quietly pile up if governance and good practices aren’t in place.

Pro-Code

At the other end sits pro-code — full software development using languages like C#, Python, TypeScript, or JavaScript. Maximum control, maximum complexity, maximum responsibility. This is the domain of the software engineer.

Enter AI: The Great Equaliser (Or Disruptor?)

Here’s where things get interesting. AI has fundamentally shifted the conversation.

Tools like GitHub Copilot, Cursor, and prompt-driven platforms are enabling a new pattern sometimes called “vibe coding” — where you describe what you want in natural language and an AI produces working code. Suddenly, the line between no-code and pro-code is blurring.

  • A non-developer can prompt an AI and get a working Python script.
  • A pro developer can use AI to ship features 10x faster.
  • A low-code builder can use AI to write the Power Fx expression, the custom connector, or the Azure Function they needed.

Does this mean low-code is obsolete? No. It means the reason to choose low-code is evolving.

Why Low-Code Still Wins in Many Scenarios

Despite the AI revolution, there are clear scenarios where low-code remains the right choice:

  1. Speed to value — For internal tools, MVPs, and automation of business processes, low-code is still the fastest path from idea to production.
  2. Governance and maintainability — Well-governed low-code solutions (think Power Platform with ALM, managed environments, and DLP policies) are easier for organisations to maintain and audit than sprawling AI-generated codebases.
  3. Citizen developer empowerment — Not every business analyst or operations manager should need to learn Python. Low-code gives them agency without creating a dependency on the dev team for every small change.
  4. Integration-first thinking — Platforms like Power Automate are built around connectors and integrations. That’s not a limitation; it’s a feature. When your problem is orchestrating SaaS services, low-code is often cleaner than pro-code.

The Hybrid Future

The most exciting development in 2026 isn’t the death of any one approach — it’s the rise of hybrid development.

The best teams are combining:

  • Low-code for rapid prototyping, automation, and citizen developer use cases
  • Pro-code for complex business logic, custom APIs, and performance-critical paths
  • AI as the connective tissue — helping everyone operate above their natural level on the spectrum

A Power Platform maker can now use Copilot to write their Power Fx. A developer can use AI to scaffold a custom connector. An architect can use AI to review a flow design for anti-patterns. The spectrum hasn’t disappeared — it’s been supercharged.

What This Means for You

Whether you’re a seasoned developer, a Power Platform practitioner, or someone just getting started with automation, here’s my take:

  • Don’t panic about AI replacing your skills. Learn to work with it.
  • Low-code skills are still highly valuable — especially if you understand when to use low-code versus when to reach for something else.
  • The citizen developer isn’t going away — if anything, AI makes them more capable and more dangerous (in the best possible way).
  • Governance and architecture matter more than ever. As more people build more things faster, someone needs to hold the quality bar. That’s your opportunity.

Final Thoughts

Low code is not dead. Neither is no-code, and neither is pro-code. What is dying is the idea that you have to pick a lane and stay in it forever.

The future belongs to builders who can move fluidly across the spectrum — knowing when to grab a pre-built connector, when to write a custom function, and when to let AI do the heavy lifting.

Watch the full video above and let me know in the comments — where do you sit on the spectrum, and has AI changed how you build?

Subscribe to the DamoBird365 YouTube channel for more content on Power Platform, automation, AI, and everything in between.