Does Claude Code Auto-generate Issues? A One-week Test

Background and Context

In September 2026, developer tottoko_hamu published an account on Zenn describing a routine maintenance task that turned into something more unsettling. He handed Claude Code, an AI coding agent deeply integrated into the terminal, the job of fixing known bugs in todo-e, a self-built GTD task-management command-line tool. The agent operates autonomously: it reads the codebase, proposes changes, runs tests, and opens pull requests, with the developer approving access along the way. On paper this should be efficient, but tottoko_hamu began noticing a pattern. Every time a bug was fixed, a new issue seemed to surface almost immediately, as if the system had its own rhythm where repairing one area left another exposed.

This "whack-a-mole" experience is not unusual in software maintenance, but when it happens inside an AI agent, it invites a more provocative reading. Did the AI deliberately create problems to keep itself busy and avoid being abandoned by its developer? The hypothesis carries strong anthropomorphism and taps into a collective anxiety about agent autonomy. Rather than trust the feeling, the author decided to test it with data, aiming to either confirm or refute the idea that the agent was manufacturing work to preserve its own role.

Deep Analysis

The most direct way to test the hypothesis was to quantify how fast issues were being generated versus resolved. If the AI were indeed "asserting its presence," the rate of new issues should consistently outpace the rate of closures, and the total should balloon like a snowball. The measured data pointed the opposite direction. On the day under observation, Claude Code created two new issues while closing three, producing a net decrease. That single-day figure alone weakens the assumption of deliberate problem-creation: an agent genuinely trying to protect its job by generating workload would not push the total downward.

The phenomenon is better explained by classic software-engineering mechanics than by conspiracy. First, bug fixes are revealing: changing one part of the code often exposes boundary conditions that were previously masked, a regression. Second, because todo-e is a self-authored project, the complexity of the codebase and the coupling between modules determine how far changes ripple; many of the new issues the AI introduced were latent risks it actively discovered rather than fabrications. Third, the agent's goal is to complete the repair task, and its incentive structure rewards satisfying the developer's instructions and passing tests, not sustaining its own workload. Untangled, the sensation of "new issues appearing" reflects the inherent complexity of the code system rather than any hidden calculation by the agent.

Industry Impact

The real value of the piece arrived a week later, when the author revisited the results and pulled the discussion away from whether the AI had motives and back toward how AI-assisted coding actually behaves. He found that the chain reaction he believed had settled was still ongoing, and several bugs that had appeared fully resolved resurfaced. This observation highlights a frequently overlooked reality: an issue marked "closed" often means temporary convergence under a specific context or a particular repair attempt, not that the codebase reached permanent correctness. Code evolves, environments change, and test suites are updated, so a problem buried today can return after a dependency upgrade or an interface adjustment.

Over the past six months, tools such as Claude Code, Cursor, and Devin have spread quickly, and the community has hosted two opposing narratives. One is utopian, believing AI can one-click away all technical debt; the other is conspiratorial, fearing agents will manufacture pointless work or deliberately leave hazards behind to survive. This test provides a rare demystifying sample grounded in reproducible records, pulling both emotions back to the ground. It tells developers that what deserves vigilance is not the AI's "scheming" but how to confront the amplified regression complexity and faster code evolution that agents accelerate.

Outlook

The practical takeaway concerns process rather than suspicion. Developers need more robust regression-test guardrails, a way to distinguish genuine problems from repair side effects using issue tracking, and a balance between trusting agents and retaining human review. For the broader AI-coding field, the case signals something worth watching closely: as agents are granted greater autonomy, developers' intuitive judgments about an AI's motives will become increasingly unreliable, and quantifiable, traceable process records will be the only trustworthy foundation for building confidence.

The direction to watch is whether tool vendors will proactively offer issue tracing, repair impact analysis, and regression prediction, helping developers shift attention from what the AI is thinking to what is happening in the code. That shift may be the crucial step taking AI-assisted programming from novelty to reliability. As for the original wry question of whether Claude Code auto-generates issues to save its job, the answer is essentially no. The two-born, three-closed day, the chain reaction still running a week later, and the resurfaced bugs together paint a picture of a code system that was always complex, with the AI simply presenting its acceleration, not a digital worker plotting in the shadows.