To find what AI-written code broke before your users do, watch production, not only the pull request. Tag every deploy, record errors as grouped issues, get told when a new issue appears after a release, and hand that issue straight back to the coding agent that wrote the code, with its stack trace and root cause.

The argument of the month is whether AI coding agents produce fragile code. Evan X. Merz, who says at least 90% of his code at Meta was AI-generated, lists the symptoms: more incidents, longer recovery because nobody knows the code, and errors only real users see because error handling was skipped.1 The Hacker News thread on his post passed 600 comments, most of them about tests and code review.2 Google's 2025 DORA report found AI adoption still has a negative relationship with delivery stability.3

This post is not about whether to keep using Claude Code. You will. It covers the half the thread skipped: the code has shipped, something in it is wrong, and you want to know before a customer emails you.

How AI-written code breaks in production

Agent-written code does not fail in new ways. It fails in the old ways, more often per week, in code fewer people on the team have read closely. These are the patterns Merz and the thread describe, and what shows each one in production.1,2

PatternWhy it slips throughWhat it looks like in productionWhat catches it
Happy-path tests onlyGenerated tests cover the paths that already exist: one user type, simple inputs. Coverage looks high.Errors on inputs nobody tested: an old account, an empty field, a plan from before a migration.A new issue on the first real failure, with the request trace that carries the input.
Big diffs, skimmed reviewPull requests arrive faster than people can read them, so reviewers skim.Something breaks in a part of the diff nobody looked at.Issues first seen right after the deploy, compared against the deploy time.
The same rule written twiceAn agent adds a second implementation of logic that already exists. The two drift.One path works, the other fails for the same customer.Grouping by root cause: one issue with one culprit frame, not two vague symptoms.
Error handling left outThe happy path works locally, so nobody asks what happens when the API call fails.Errors only real users see: a 500 on a retry, a job that dies on a timeout.Alerts on new issues and error bursts, plus an uptime check from outside.
Nobody knows the codeThe person on call did not write the module and never read it.Recovery takes longer, because you start by learning the code.An investigation that reads the stack and source and states the mechanism.
A fix that undoes itselfA later change quietly brings the old bug back.An error you resolved last month returns.Regression alerts on issues you marked resolved.

Patterns from Merz's post and the Hacker News discussion, checked November 17, 2026.1,2 Differences between your laptop and production (config, data volume, concurrency) are a separate list: see why an app works locally and breaks in production.

How to find what broke before users do, in six steps

Tests and review stay. They catch what you thought of. Production shows you what you did not, with real data and real users. A small team needs six things in place, and none of them needs a platform team.

  1. Mark every deploy. Set the OpenTelemetry resource attribute service.version to your release or commit id; the spec itself uses a short commit hash as an example value.4 Set deployment.environment.name=production too, so a fault that sat in staging is told apart from one that just reached users.5 This is what lets you say "this started with that deploy" instead of guessing.
  2. Record errors where they happen. Exceptions on traces and error-level logs, sent over OpenTelemetry, not printed to a console nobody reads. A handler that catches an error and logs it without a level files it as info, so give every log line a severity.
  3. Group errors into issues by root cause. A refactor that throws 3,000 times should be one row with a count, not 3,000 lines. Grouping that ignores ids, timestamps and hostnames keeps variants of the same failure together.6
  4. Get told about new issues, not every error. The signal after a deploy is "this has never happened before". Alert on new issues, on bursts, and on issues you already resolved coming back. Email or Slack, wherever you will actually see it.
  5. Check the deploy, not only the build. After each release, ask what is new: issues sorted by first seen, compared with the deploy time.8 Add an uptime check from outside for the failure that logs nothing, like a service that will not start. More on this in how to know when your app goes down.
  6. Fix from evidence, then add the test that was missing. Give the agent the issue, the stack trace and the failing request, and ask for the fix plus a test with the real input that broke. That test is the one the happy-path suite never had.

Steps 2 to 4 are what error tracking does; production error tracking for small teams walks through them in detail, with what to measure. What changes when the code is agent-written is step 1 and step 6: you need to tie each failure to a change, and you need to get it back to the agent with enough context that it fixes the cause, not the symptom.

Hand the issue back to the agent that wrote it

"Nobody understands the code" is a real cost when a person has to debug it cold. It matters less when the debugging starts from evidence and the agent that writes the fix reads the whole module before it changes anything. What the agent cannot do is see production. A paste of a customer's complaint gives it nothing to work with; an issue gives it the exception, the frame in your code that threw, the trace of the request, the logs around it and when it started.

So connect your monitoring tool to Claude Code over MCP and work in the same session where the code was written. Ask what is new since the deploy, read the root cause, and ask for the fix and the test. Then review it the way you would any change. Which tools have an MCP server, and what each can read, is in monitoring MCP servers for Claude Code, compared; the setup steps are in debugging production from Claude Code.

Doing this with Fixter

Fixter is ours, so weigh this section with that in mind. Fixter (fixter.dev) finds and fixes the issues in your app in production, from your coding agent: errors, failing infrastructure, slow requests and downtime. It finds the root cause and fixes it: in your agent over MCP, or as a pull request ready for your review. Nothing to learn, built for small teams.

Against the six steps: your app sends logs, traces and metrics over standard OpenTelemetry, and every error becomes part of an issue grouped by root cause, with the frame in your code that caused it.6 The first time a fault reaches production, you hear about it by email or Slack, even if it has been sitting in staging for a week. An issue you resolved that comes back reopens and tells you.6 Each new issue is investigated: what broke and why, the evidence, whether it is your code, a dependency or infrastructure, and a suggested fix.6,7 Then you take it from your coding agent:

Claude Code, example
> what is new in production since this morning's deploy of billing?

1 new issue in billing (production), first seen 6 minutes after the deploy
  TypeError: Cannot read properties of undefined (reading 'currency')
  culprit: applyProration (src/billing/proration.ts)
  412 events, 37 accounts, still occurring

Investigation:
  root cause  the new proration path assumes every plan has a price
              object; legacy annual plans do not
  origin      your code
  severity    breaking
  fix         fall back to the plan's stored currency when price is missing

> fix it, and add a test with a legacy annual plan

An illustration of the flow, not output from a real account.

You can also copy a ready fix prompt from any issue, or let Fixter open a pull request with the fix for you to review.6,7 To set it up, paste this into Claude Code, Cursor or Codex in your project: Read fixter.dev/llms.txt and set up Fixter. Free plan, no card. AI investigations are on the paid plans, from €20 a month.9

Key takeaways

  • AI-written code fails in familiar ways, more often, in code fewer people have read
  • Tests and review catch what you thought of; production shows the rest
  • Tag every deploy with service.version so each new issue ties to a release
  • Alert on new issues and regressions, not on every error
  • Hand the issue back to the agent with its evidence, and ask for the missing test with the fix

Frequently asked questions

Does AI-generated code break more often in production?

The best data so far points that way at the team level. Google's 2025 DORA report found that AI adoption now goes with higher delivery throughput, but still has a negative relationship with delivery stability: more change means more chances to break something unless testing and feedback loops keep up. It is a pattern across teams, not a rule for every codebase.

How do I find bugs in production before my customers do?

Record every error your app throws, group repeats into one issue per root cause, and get told when a new issue appears, especially right after a deploy. Add an uptime check from outside for the cases where nothing gets logged at all. Then fix from the issue's stack trace and root cause instead of from a customer's description.

How do I know which deploy introduced an error?

Set the OpenTelemetry service.version resource attribute to your release or commit id on every deploy, and the environment with deployment.environment.name. Then compare when each issue was first seen with your deploy time. An issue first seen minutes after a release is almost always that release.

Should a small team stop using AI coding agents because of this?

No. The breakage the critics describe comes from shipping more change than the team can follow, not from the agent itself. The fix is the production half of the loop: see what broke, know why, and hand it back to the same agent with the evidence. That keeps the speed and puts a check on what reaches users.

Can Claude Code fix a production error on its own?

It can once it can read the error. Connect a monitoring tool over MCP and Claude Code can pull the issue, its stack trace, the trace of the failing request and the logs around it, then change the code in your repository. You still review the change and decide when it ships.

Sources (9), all checked November 17, 2026
  1. Evan X. Merz, "AI usage generates a fragile codebase" (November 7, 2026)
  2. Hacker News discussion of that post (647 points, 626 comments when checked)
  3. Google Cloud, announcing the 2025 DORA report (September 24, 2025)
  4. OpenTelemetry semantic conventions, service resource attributes (service.version)
  5. Fixter docs, OpenTelemetry setup (naming the environment)
  6. Fixter docs, Issues (grouping, environments, statuses, investigation brief, fix prompt)
  7. Fixter docs, Investigations (pick up in your coding agent, pull requests)
  8. Fixter docs, MCP tools reference (list_issues, get_issue)
  9. Fixter pricing