色控传媒

By Par Botes, VP AI Infrastructure, 色控传媒

For years, there’s been a trend in software development toward simplification and utility. Glue code was used to connect otherwise incompatible software modules. No-code was in vogue to create software by dragging and configuring images. It all seemed so much easier than putting all of this together with old-fashioned systems programming. And for a while, it was.

Guess what, though: Simplicity is dead. Long live the new simplicity.

What’s happening today in software development, particularly around large language model AI and its associated technologies, is going to bury glue code and no-code. Even the related field of low-code, with lots of drag-and-drop interfaces, may soon be a thing of the past.

That’s because AI-assisted coding does the same thing, faster and better. Glue code isn’t necessary if a Model Context Protocol (MCP) server can offer all the necessary context and methods for the LLMs to connect things and build transformations and logic as needed. Let the machine figure itself out! So-called “vibe coding,” or ordering up code creation based on stating prompts, can be even easier and better than no-code, which only ever worked in limited contexts.

As always with a technical change, AI-assisted coding will only become common with some painful corporate and senior engineers’ reworking, which can be tougher than the technology itself. Some, especially those invested in pull-down menus, think this transition is a terrible thing. Glue code held things together in a reliable way. If agentic systems come after the container-based connectivity of microservices like Docker and Kubernetes, there will be lots of turmoil in the DevOps world.?

I have two pieces of advice. One, the best people are great at what they do because they’re exceptionally good at giving up old habits and learning new things when more promising choices arrive. As a leader, you should expect internal resistance and turf wars, but recognize these are market- and efficiency-losing impediments if they’re only about preserving the status quo.

And two, remember that the things we’ll be giving up, like glue code and no-code, were never ends in themselves. They’re means to a better experience, and that is always the key thing a technology should seek to produce.

In its time, glue code allowed us to access libraries and map objects, but as they caught on, they tended to generate a lot of low-value technical debt, with no central observability. Ultimately, talented people became tasked with adjusting the code for API compatibility as dependent software evolves, and that, by itself, frequently becomes a never-ending treadmill. A more experienced, and perhaps a bit more cynical, engineering leader than I makes the point that this became management of complexity created in the quest for simplicity. He isn’t all wrong.

In less than a year since its launch, MCP has delivered a fundamental premise: its ability to eliminate human creation of DevOps-type code for repeatable actions, taking away the hazards of technical buildup and never-ending version tracking and other associated technical debt. There’s some over whether MCP is a new kind of middleware and how that will affect several existing players. Even the fact that this was talked about just a few months after its popularization and well before the community critical mass suggests its potential.

No-code started out solving a problem, and with its success, created new problems of its own. The no-code proposition was that writing software could be as simple as putting together LEGO blocks. It turned out, though, that beyond the most elementary programs,? even the best no-code projects got you 90% of the way there. Specialists had to dive in, figure out what was going on, and adjust the code for the sake of relatively simple programs. By comparison, the natural language capabilities of AI programming, translating desires for outcomes into usable code, suggest a better path.

This isn’t to say that AI coding won’t have its own challenges. Doing really interesting things with computers is almost never simple. The new methods are teaching a whole generation of people how to be extremely specific with defining outcomes and context so well that the machine outputs functioning programs are the new point of orientation. I submit that this will make better programmers since engineers will be forced to think harder about the end state and not just discover the details that they can adjust for as they go along. No, I’m not saying that minimum viable is dead either, but being specific on outcomes doesn’t preclude leaders from sharpening their scope and expanding over time.

There are probably new kinds of hard work that will come with the new approach. Vibe coding may at first sound like the software version of Aladdin’s lamp (“you name it, I’ll code it”), but two eminent developers have just published a 300-page on the topic. That suggests many of us face a new learning curve ahead.

The meta point is important: Focus on the experience you seek to deliver. Recognize that large-scale programs are perfectly fine to be interconnected and operate with minimal human intervention. The functionality that propelled so much effort in glue code, low-code, and no-code software can become incidental, thanks to the intricate richness of LLMs.

We’re already in a period of perfecting the art of working with these new tools. We’ll need to build systems to provide deep context, so LLMs function at optimal levels within the context of enterprises. They’ll need means to develop context for corporate knowledge, not to mention the conventions, beliefs, and organizational structures that make up not just governance, but important dimensions of corporate culture.?

The old tools of simplicity cannot match the new touchstone experiences. They were great in their time. I used many and loved them, but their time has passed. Welcome to a new age of context and action. If you’re an engineer, my advice is to get started. If you are a technology leader, my advice is that you focus your attention on ensuring that the definition of outcomes we ask these tools to create is complete, detailed, and traceable.

?