[The Degradation Loop: When AI Users Stop Pushing Back]

There's a version of working with AI that feels transformative: you describe a problem, the agent produces something useful, you refine it, and you ship faster. The feedback loop is tight, the output is good, and the time you've saved is real.

Most people who use AI daily have experienced this. Fewer have noticed what happens months later.

The speed gain is real. So is the erosion; it just happens slowly enough that most people don't notice until it's already happened. The bar you apply to what the agent gives you starts to shift. Not dramatically (you're not accepting obviously bad output), but the threshold for "good enough to move forward with" drifts slightly downward, week by week, until you're operating at a quality level that would have bothered you when you started.

This is the degradation loop. It's not a bug in the AI, nor a personal failure, but a predictable consequence of how the human side of the human-AI interaction works under sustained cognitive load. Understanding the mechanics of it is the first step to not being captured by it.

The loop has a recognizable shape, and once you've seen it, you'll see it everywhere:

• Phase 1: Active engagement
  You're new to the tool or new to a task type. You read the output carefully. You notice when it's wrong or off-key. You push back, rephrase, and iterate. You’re not training the model, but you are training the session and yourself: each correction becomes part of the shared context, and you get sharper about what to ask for and what to reject.
• Phase 2: Comfortable reliance
  The tool is working well enough that you trust it by default. You still review the output, but less carefully. You're pattern-matching on surface features: length, structure, and apparent coherence, rather than reading for substance. The gap between "looks right" and "is right" starts to open.
• Phase 3: Passive consumption
  Reviewing feels like it takes more time than it saves. You're tired, the deadline is close, and the output is probably fine. You accept it. Then you do it again. Then it becomes the default.
• Phase 4: The reset that doesn't happen
  Because the output never becomes dramatically bad, there's no obvious trigger to re-engage. The quality degradation is gradual enough to be rationalized at each step. The comparison baseline (what you'd have produced yourself, or what you used to demand) has moved without you tracking it.

As a team, we ended up naming this dynamic in one of our internal reviews. I described it to the group this way: "In the beginning, there's a stage where the person is willing to prompt and configure the rules. Then they're no longer willing to. Their personal standards drop, and they just end up in a consumption cycle."

The loop is closed not by the AI getting worse but by the human stopping to notice.

People who fall into the degradation loop aren't lazy or careless; the loop happens because accepting output and correcting output are not symmetrical acts, and the system consistently rewards the former over the latter.

Accepting what the agent produces takes seconds. Identifying that it's wrong, articulating why it's wrong, and formulating a correction that actually fixes the problem: that takes real cognitive work. When you're operating under time pressure, cognitive fatigue, or both, the path of least resistance is to accept it, and the output is usually plausible enough to make acceptance feel reasonable.

This is what researchers call automation bias: the tendency to over-rely on automated systems and under-apply critical evaluation when the system's output appears credible. It's been documented in aviation, medicine, and financial analysis. It appears in AI-assisted knowledge work for the same reason it appears everywhere else: the cognitive cost of maintaining critical engagement against a confident-sounding system is high, and human attention is finite.

The asymmetry is compounded by the loss of comparison baselines. When you've been working with an AI assistant for months, you may not clearly remember what your unaided output looked like. You can no longer easily distinguish between "this is good" and "this is what I've come to expect." The reference point that would allow you to notice degradation has eroded.

This represents a structural feature of the human-AI interaction that requires structural responses: habits and systems, not willpower.

The uncomfortable truth about the degradation loop is that you usually don't experience it as degradation. You experience it as efficiency.

A few signals that suggest the loop has set in:

• You've stopped reading carefully. You scan the output for obvious errors and move on. If nothing jumps out, it's fine. You haven't asked whether the framing is right, whether the logic holds, or whether there's something important missing.
• You edit less than you used to. Early in your use of the tool, you probably changed a lot. Now you change a sentence here and there, mostly cosmetic. The output's structure and substance stay largely as produced.
• You can't easily articulate what "good" looks like for this task. When you try to give feedback to the agent, you struggle to specify what's wrong. You know it feels off, but you can't say why. This is a sign that your standard has become implicit and fuzzy rather than clear and operational.
• You feel resistance to doing the task without the tool. Not because the task is harder, but because you've forgotten how. The skill atrophied because the agent was doing most of the cognitive work.
• You've started defending the output without having verified it. You're advocating for something the agent produced as if you'd produced it yourself, without having done the substantive check that would make that confidence warranted.

None of these individually is disqualifying; all of them together suggest you've drifted from using AI as a force multiplier to using it as a replacement for your own judgment.

There's a version of AI-assisted work that is genuinely excellent: you're moving fast, the output quality is high, and the human judgment in the loop is sharp. Call this a flow, and there's a version that looks identical from the outside but is quietly hollowing out the quality of your work: you're moving fast, the output quality is acceptable, and the human judgment in the loop has been progressively outsourced to the agent. Call this drift.

The difference between them isn't speed or even output quality at any given moment, but whether your critical faculties are engaged or dormant.

In flow, you're using the agent to handle the mechanical and generative parts of the work, so your judgment can focus on what matters. You're deciding what the task should accomplish, evaluating whether the output achieves it, and bringing domain knowledge and standards to the review.

In drift, the agent is handling all of that. The human in the loop is providing continuity and a signature, not judgment.

Andrej Karpathy coined "vibe coding" in a February 2025 tweet to describe a mode of development where you fully surrender to the agent's output: "forget that the code even exists." The term has since broadened to describe any uncritical acceptance of AI-generated work, well beyond software development. The same pattern appears in writing, analysis, research, and management; the common thread is the replacement of substantive evaluation with surface-level pattern matching.

The goal isn't to second-guess every output; that would negate the speed benefit and isn't sustainable. The goal is to maintain the quality bar without turning every AI interaction into a manual review process. A few practices that work:

1. Define what "good" looks like before you generate. Before you ask the agent for anything substantive, write one or two sentences about what you want the output to accomplish and what it needs to get right. This forces you to clarify your standard before you see the output, which makes it much easier to evaluate the output against something specific rather than against a vague sense of quality.
2. Separate generation from evaluation. Don't review the output immediately. Step away, come back with fresh attention, and read it as if someone else produced it. The psychological distance makes it easier to notice problems you'd rationalize away if you were in the production mindset.
3. Keep a set of tasks you do without the tool. Deliberately preserve some work that you do entirely under your own power. This keeps the comparison baseline alive. It also keeps the underlying skill active, which matters both for quality evaluation and for the cases where the agent can't do what you need.
4. Set a correction quota. For any significant AI-assisted task, find at least one thing to change beyond cosmetic edits. Not as an exercise in skepticism, but as a discipline for staying engaged. If you genuinely can't find anything to change, that's useful information; either the output is genuinely very good, or your critical engagement has dropped below the threshold needed to detect problems.
5. Track when you've accepted something you weren't sure about. A brief log (even a mental note) of moments when you went with the output despite uncertainty creates a data point you can review. Patterns across those moments often reveal where your standards have drifted.

None of these practices is onerous. The common thread is that they keep the human in an active rather than passive relationship with the output. That distinction (active vs. passive) turns out to be the thing that separates two modes of AI-assisted work that look identical from the outside but produce very different results over time.

The acceleration AI offers is real, and so is the cost of outsourcing your judgment to collect it. The risk isn't that the agent suddenly starts producing terrible work; it's that you gradually stop noticing the difference between "good" and "good enough" for the problems you actually care about.

The practices above are all about staying the person who decides what the output means, whether it's good enough, and what should happen next. That role becomes more important because the agent can now produce more output faster than you can evaluate it passively.

As agents get better and take on more of the work, the stakes of that role go up, not down. The systems will keep getting faster either way; the question is whether your standards and your judgment keep pace with them.