We’ve been here before.

RPA wasn’t stupid. It was a pragmatic response to a real problem. Most enterprise systems were never built to be programmatically accessible. They were designed for humans — point, click, fill, submit. No APIs. No CLIs. No webhooks. Just screens. RPA was the duct tape we wrapped around that reality. It was brittle, broke on every UI change, and created a maintenance nightmare — but it solved a legitimate problem: these systems gave you no other way in.

Now look at what’s happening with AI agents.

“Computer use.” Screenshot-based reasoning. Agents that navigate browsers like a person would. We’re building the same duct tape again, just with better vision models. The screen is not an API. It wasn’t then. It isn’t now.

The Sysadmin Problem

This is where the conversation gets uncomfortable — and honest.

Talk to any infrastructure team about GitOps and watch the room tense up. Not because they don’t understand it. Because adopting it means fundamentally rethinking how they operate.

Today, a sysadmin’s power lives in the web console. They click through dashboards, toggle settings, provision resources, troubleshoot in real-time — all through a browser. Their expertise is encoded in muscle memory and institutional knowledge of where things live in the UI. Knowing which screen, which tab, which buried setting — that’s the moat.

GitOps says: take all of that and express it as code in a repository. Version it. Review it. Automate it. And suddenly the thing that made you indispensable — the deep familiarity with a console’s geography — becomes a commodity. Declarative config files don’t care about your ten years navigating the AWS console.

This isn’t laziness. It isn’t technophobia. It’s rational self-preservation. But it’s also the exact thing that’s blocking us from building systems that agents — or even just better automation — can reliably operate.

Because here’s the thing: if your infrastructure can only be managed through a web UI, you haven’t just created a human bottleneck. You’ve created an agent bottleneck. And the response to that bottleneck will be the same bad shortcut we took with RPA — point an AI at the screen and pray.

The Pattern Is Everywhere

Every team that manages infrastructure through a web interface instead of code is recreating the same problem RPA tried to solve fifteen years ago: a system with no programmable surface. And every time the answer is “let’s automate the clicks,” we’re choosing the wrong layer.

In the era of agentic engineering, this matters more than ever. If we want agents that compose, that chain, that operate across systems reliably — we have to express interactions as what they actually are: structured operations. Not visual navigations.

Code over clicks. An agent shouldn’t “navigate to settings and toggle the switch.” It should call config set feature.enabled true. One is fragile theater. The other is deterministic and auditable.

Configuration over conversation. Stop describing what you want in fifteen rounds of chat. Declare it. A YAML file, a Terraform plan, a Helm chart — these are the real prompts for agentic systems. They’re reviewable, diffable, and rollback-friendly.

CLIs and APIs over dashboards. Every tool that only exposes a GUI is a tool that can’t participate in the agentic future. You’ve built a dead end with a nice coat of paint.

Why This Matters Now

The reason GitOps matters more today than it did five years ago isn’t just about DevOps best practices anymore. It’s because a Git repo full of declarative config is something an agent can reason about, modify, submit a PR for, and roll back. A web console with seventeen nested menus is something an agent can only screenshot and guess at.

That’s the real divide forming in engineering organizations: teams whose infrastructure is expressed as code — and therefore agent-ready — versus teams whose infrastructure is locked behind web consoles that only a human with the right muscle memory can navigate.

The first group is building for what’s coming. The second group is going to get the AI equivalent of RPA: impressive demos, fragile in production, and expensive to maintain.

The Real Agentic Engineering Challenge

It’s not building better screen-reading AI. It’s building — and adopting — systems that are agent-native from the ground up. Structured inputs. Predictable outputs. Programmable surfaces.

RPA failed not because automation was a bad idea, but because it automated the wrong layer. It interacted with the presentation instead of the intent. We’re about to make the same mistake at scale, with more capable models, and call it innovation.

We don’t need agents that are better at pretending to be humans using software. We need engineers willing to stop pretending that clicking through a UI is engineering.

The agentic era doesn’t need a better eye. It needs a better handshake.

If this argument resonates, you might also enjoy Claude Code vs. GitHub Copilot CLI — a practical look at what CLI-first agent tooling actually looks like in practice.

Follow the conversation on X @orestesgarcia or connect on LinkedIn.