Ask any developer what is the least satisfying part of the job, and the glue code comes up quickly. Not a difficult, interesting task of designing systems or solving real problems. The second type: plumbing. Writing another script to synchronize two APIs that talk to each other but don't. Creating and maintaining delicate connections between systems that each have their own schemas, verification flows, and habits of changing things without warning.
It is necessary work. It is also the kind of work that burns out capable people, because it scales badly, breaks quietly, and is never actually finished.
AI is starting to change that, and the change is more interesting than most AI coverage suggests.
Why Integration Work Never Went Away
Software has become more powerful every year. Tooling has improved, languages have evolved, the cloud has simplified infrastructure to a level that seemed impossible a decade ago. Yet the problem of integration remains, because it is not primarily a technology problem. It is a problem of proliferation.
Every tool that a company adopts has its own island. Every SaaS product, internal service, and third-party API speaks its own language. The logic of eliminating them doesn't last until someone writes it, and once it's written, it has to be maintained, version created, and patched when upstream changes.
The typical pattern goes like this:
- A business need emerges that requires two systems to exchange data.
- A developer writes a script or a custom integration.
- It works. Nobody touches it for months.
- A vendor updates their API, and something breaks silently.
- Someone discovers the breakage, usually from a downstream symptom.
- The cycle repeats.
For small, stable integrations this is manageable. At scale, across dozens of systems and hundreds of connections, it becomes a significant maintenance burden that competes with product work for engineering time.
What AI Agents Actually Change Here
The development worth paying attention to isn't the AI that writes the integration code for you, even though it exists. It's the AI that performs the integration directly, completely removing the code layer for a large class of routine contacts.
Modern AI agent platforms can accept natural language explanations of what needs to happen, decide which systems to interact with, handle verification and data conversion, follow steps, and manage failure cases. The AI flow that results is observable, logged, and maintainable, without any codebase that requires ownership.
For a developer, the practical implication is significant. The category of work that previously required writing and owning custom code, namely the routine, predictable, rule-based data movement between systems, can increasingly be described rather than coded. That does not eliminate development. It shifts what development time is for.
The Bigger Shift: Who Gets to Build
Another impact is noteworthy, as it impacts the broader software ecosystem. One of the constant failures in software development is the gap between the person who understands the problem and the person who develops the solution. A business analyst knows very well what should happen when a deal closes in a CRM. A developer has to put this understanding into the code, in meetings and specifications and back and forth, and then own the outcome.
When making a connection means articulating it in plain language and executing it on a platform, the analyst and developer are no longer separated from the translation layer. Anyone who understands the process can make it straightforward, at least for the problems of this class that are well defined and rule-based. Platforms going from prompt to app are taking this further, developing detailed working tools and interfaces instead of codebases.
This is not the end of programming. Complex systems, critical code for performance, and genuinely new problems will require real engineering for the foreseeable future. But a meaningful piece of work that currently lands on developer queues, especially routine, repetitive, well-defined integrations, is becoming automated at the level of clarity.
What This Means for the Developer's Role
None of this reduces the value of strong engineering. If anything, it clarifies where that value lies.
Developers who spend their time writing and maintaining glue code are not using their hardest-won skills. Those skills, system design, performance reasoning, debugging complex failures, building for scale, are not what integration scripts require. What they require is patience and familiarity with APIs, which is a significantly lower bar.
As that category of work becomes automatable, the developer's role naturally shifts toward the harder problems. Designing the systems that AI agents operate within. Defining the security and access boundaries that govern what agents can touch. Debugging and improving the automations themselves. Building the complex, bespoke software that still requires a human who understands a machine at a deep level.
It is, in some ways, the same shift that happened when higher-level languages replaced assembly. The complexity did not disappear. It moved to a higher abstraction layer, and programming became accessible to more people while the most capable programmers moved to harder problems.
Conclusion
Glue code has always been the tax developers pay for working in a world of disconnected systems. AI that can execute integrations from a description is starting to reduce that tax, not by making the problem disappear, but by handling the routine, rule-based instances of it without a codebase.
For developers, this is mostly good news. The tedious maintenance burden that competes with real engineering work has a credible alternative. The hard, interesting problems, the ones worth a skilled engineer's time, are not going anywhere. They are, if anything, becoming easier to reach.
FAQs
Does AI replacing glue code mean fewer developer jobs? Answer: No. It removes the lowest-value part of the work, freeing developers for the harder problems that require real engineering skill.
What kinds of integrations can AI handle? Answer: Routine, rule-based data movement between systems with predictable steps. Complex, novel, or performance-critical integrations still need custom code.
Is AI-generated integration code the same as AI-executed integration? Answer: No. AI that generates code still produces a codebase you own and maintain. AI that executes integration removes that layer entirely for supported use cases.
What does a developer need to know to work with AI agents? Answer: System design, security boundaries, access scoping, and how to evaluate what an agent can and cannot be trusted to do.
What still needs a developer? Answer: Complex, bespoke software, performance-critical systems, deep debugging, and designing the infrastructure that AI agents operate within.
