While billions flow into AI coding assistants like GitHub Copilot, Cursor, and Windsurf to make developers more productive, and a new wave of tools like Replit, Bolt.new, v0.dev, Loveable, and even Canva let anyone create entire applications without writing code, I have to sit back and think that the industry is missing the point a little.
Many are thinking in terms of "better programming" or "no-code app creation" where I instead see untapped potential. An opportunity to do something remarkable.
Right now, we're mostly making the same mistake we always make with new technology. We try to use it to do the old thing slightly better instead of rethinking what we should be doing entirely. It's like when computers first arrived in offices. Did we have them pressing the keys on our typewriters? Of course not. That would be absurd.
Yet here we are, using AI to write code faster when we should be questioning why we need code at all.
Think about what these AI coding tools actually do. They autocomplete your functions. They suggest the next line. They catch syntax errors. They even debug your logic.
Impressive? Sure. Revolutionary? Not really.
They're making us more efficient at creating the very thing that might not need to exist.
Let me paint you a picture of modern software development. You want to add a simple feature to your business. Maybe it's a new discount type for loyal customers. The next part is telling:
First, someone writes a requirements document. Then a developer interprets those requirements into code. The code gets reviewed, tested, deployed. Bugs are found and fixed. APIs change and break things. Requirements were misunderstood, so more code gets written. Months later, you want to tweak the discount logic. But the original developer left. The new developer has to read through thousands of lines of code to understand what's happening. They make changes, hope nothing breaks, and the cycle continues.
We've built entire industries around managing this complexity. Version control, testing frameworks, deployment pipelines, monitoring systems. We've accepted that software is necessarily complex, brittle, and expensive to change. But does it need to always be like this?
Look at any modern commerce store. They're using Shopify for their storefront, Klaviyo for email marketing, ShipStation for fulfillment, QuickBooks for accounting. Each tool costs money. Each stores a piece of business logic. Each requires integration code to talk to the others.
When something goes wrong, good luck figuring out if it's Shopify's webhook that failed, Klaviyo's API that changed, or your integration code that has a bug. You've distributed your business logic across a dozen systems, connected by thousands of lines of brittle glue code.
And we're celebrating AI tools that help us write that glue code faster?
What frustrates me is this: we have AI that can understand natural language, reason about complex scenarios, and maintain context across long conversations. But we're using it to... generate more JavaScript?
It's like having a brilliant assistant who speaks every language fluently, understands every business domain deeply, and can reason through complex problems instantly. And we're asking them to type faster.
The real question isn't "How can AI help us code better?" It's "Why are we coding at all?"
What if business logic didn't need to be translated into code? What if you could just explain how your business works and have systems that understand and execute accordingly? What if changing a business rule was as simple as having a conversation? What if integrations didn't require APIs and webhooks and authentication tokens and retry logic?
What if software development wasn't about development at all?
I watch the demos of these new AI coding tools. Developers are genuinely excited. "Look how fast I can build a CRUD app!", "Check out this complex algorithm it generated!", "It found a bug I would have missed!"
But step back.
Why are we building CRUD apps in 2025? Why are we manually implementing algorithms that have been solved thousands of times? Why do we have bugs in the first place?
We're so deep in the programming paradigm that we can't see how arbitrary it all is. We've confused the means with the end. We've forgotten that code is just one way to express intent, and probably not the best way.
The technology to move beyond programming already exists. Large language models can understand complex business logic. They can maintain state, reason about edge cases, and make intelligent decisions. They can orchestrate existing services and APIs without writing traditional integration code.
But instead of exploring this new paradigm, we're using these incredible models to be better typists.
Stop celebrating AI that makes coding easier. Start demanding AI that makes coding unnecessary.
Stop building better tools for developers. Start building systems that don't need better tooling.
Stop optimizing the wrong thing. Start questioning whether the thing should exist at all.
The next breakthrough won't come from a better IDE or a smarter copilot. It'll come from realizing we don't need IDEs or copilots to create business logic at all.
Who's ready to have that conversation?