AI Coding Tools Are Producing Fragile Agents

The people building your AI agents may not fully understand what they are building. That is not a knock on any individual — it is a structural problem emerging as AI coding tools handle more of the cognitive work that used to build expertise.

What the "expertise collapse" argument actually says

Lars Faye's piece argues that AI coding assistants short-circuit the learning loops that turn junior developers into senior ones. The mechanism is straightforward: when a tool generates the solution before you have wrestled with the problem, you skip the failure modes that teach you why the solution works. You ship code you cannot fully debug.

This has always been true of copy-pasting Stack Overflow answers. The difference now is scale and fluency. AI-generated code looks authoritative. It passes linters. It often passes tests. The gaps only appear in production, under conditions nobody thought to test.

Why this hits agent systems harder than normal software

A standard web app fails loudly. An endpoint returns a 500. A form breaks. Users complain and you fix it.

An AI agent fails quietly. It calls the wrong tool. It misinterprets a retrieval result. It loops on an edge case and burns API tokens. It produces plausible-sounding output that is wrong in ways a non-technical stakeholder cannot catch. The feedback loops are slower and fuzzier, which means weak foundational understanding compounds into serious production problems.

Agent systems also have more moving parts than typical software: LLM calls, tool definitions, memory layers, orchestration logic, retry handling, eval pipelines. Each of those surfaces requires the builder to have a clear mental model of failure modes. If they are vibe-coding their way through with an AI assistant filling in the gaps, those mental models are thin.

The specific failure patterns to watch for

If your team is leaning heavily on AI coding tools to ship agent work, watch for these:

Prompt brittleness. The agent works on the happy path and fails on any variation. The builder got the demo working but never stress-tested the prompt against real input distributions.

No evals. There is a system prompt and a deployment, but no repeatable way to measure whether the agent is performing correctly. When something goes wrong, the team is debugging blind.

Orchestration cargo-culting. The code uses a framework like LangChain or LlamaIndex but the builder does not know why each component is there. Removing one breaks everything in non-obvious ways.

Retry logic that hides errors. Auto-generated error handling that swallows exceptions and retries indefinitely, masking real failures and making them harder to trace.

None of these problems are new. Inexperienced engineers have always introduced them. The concern is that AI coding tools make it faster to produce systems with these problems while making it feel like the work was done correctly.

What this means if you are evaluating an AI build

If you are a founder or operator looking to ship an agent, the question to ask is not "can your team build this with AI tools?" Almost anyone can produce something that demos. The question is: what happens when it hits real users?

Push for specifics. Ask how they handle retries and failure states. Ask what their eval setup looks like. Ask them to walk through a production incident they have debugged. If the answers are vague, the expertise may be thinner than the demo suggests.

Our free AI Opportunity Audit is a useful first step if you are still mapping where agents fit your business — it identifies your three highest-impact automations from your existing workflow, so you are evaluating the right problems before any code gets written.

The floor expertise a production agent actually needs

Shipping a reliable agent requires understanding a specific set of things at a non-surface level: how LLMs handle context windows and why that affects tool-call sequencing, how to write evals that catch real failure modes (not just format errors), how to structure retry logic so it fails fast rather than silently, and how to monitor an agent in production so degradation is visible before users notice it.

That expertise can be built with AI coding tools in the mix — the tools are genuinely useful for scaffolding and boilerplate. But the judgment layer has to come from somewhere real. Right now, that is the thing in short supply.

Build with someone who has been in production

If you want an agent that holds up past the demo, it is worth working with someone who has debugged one in production. Book a call and we can talk through what you are trying to automate and whether the approach makes sense.