The modern developer's workflow has shifted into a cycle of prompt and paste. The ability to implement a complex feature in seconds by leveraging a Large Language Model (LLM) has become the industry standard for efficiency. This acceleration creates a seductive illusion of productivity where the distance between a conceptual requirement and a working prototype is nearly zero. However, this speed comes with a hidden tax. As AI-generated logic seeps into the foundational layers of software, developers are increasingly inheriting code they did not write, do not fully understand, and cannot easily verify. The risk is no longer just a bug in a local script, but the systemic infiltration of unverified logic into the external libraries that power the global software ecosystem.

The Audit for Code Purity

In a decisive move against this trend, the developers of git-annex, a distributed file management tool, have undertaken a rigorous campaign to ensure their system can be built without any dependencies containing LLM-generated code. This was not a simple configuration change but a manual, labor-intensive purge. Over the course of a single month, the development team invested approximately 100 hours of focused work to identify and remove dependencies that had been contaminated by AI-generated contributions. The objective was clear: to restore a state of code purity where every line of logic is the result of human intent and verification.

This effort highlights a growing friction between the rapid adoption of AI and the traditional standards of open-source maintenance. While the industry pushes for faster shipping cycles, git-annex opted to absorb the high cost of manual review and dependency reconfiguration. This decision serves as a critique of the current trajectory of software development, where the ease of generation is prioritized over the rigor of authorship. The project's stance is particularly pointed when compared to larger institutional bodies. The author of the purge noted a disappointing lack of action from the Software Freedom Conservancy (SFC) and the Free Software Foundation (FSF). Despite the systemic risks posed by the influx of AI code into the open-source commons, these organizations have been viewed as avoidant or incapable of providing a meaningful framework to combat the issue.

The Illusion of the 10x Developer

The tension between AI speed and software stability is best illustrated by the collapse of professional trust within a development team. In one documented case, a developer attempted to optimize a project by using an LLM to add settings and restyle code for fourmolu, a Python formatter. By feeding the requirements into a prompt and committing the output directly, the developer labeled themselves a 10x developer, citing the massive leap in implementation speed. However, the result was not a productivity gain but a social and technical failure. The reckless nature of these commits, devoid of human nuance or careful review, led to a total breakdown in collaboration. The peers of this developer eventually severed ties, proving that the efficiency gained through AI can be completely negated by the loss of trust and the destruction of collaborative norms.

This breakdown is mirrored in the technical data uncovered during the git-annex audit. In a codebase consisting of 26,000 lines of code (LOC), the team discovered a single commit that introduced 10,000 lines of changes. The sheer volume of the modification was staggering, yet the accompanying commit message, which spanned 1,489 lines, was largely inconsistent and lacked meaningful explanation. This is the paradox of LLM-generated code: it can produce a mountain of text that looks like progress but functions as technical debt. In several instances, these massive AI-driven changes were so low in quality that they had to be reverted immediately in the following release. The volume of change simply exceeded the human capacity for review, rendering the traditional pull-request process useless.

Beyond the quality issues, the audit revealed a dangerous trend in how AI is used to source code. The team found LLM prompts that explicitly instructed the AI to copy code from other existing projects. While these specific instances did not result in legal action, the author noted that avoiding copyright infringement was a matter of luck rather than a result of the tool's safety guardrails. The AI essentially acted as a conduit for plagiarism, encouraging developers to bypass licensing requirements in the name of speed. This transforms the AI from a productivity tool into a liability, introducing legal risks that can jeopardize the entire existence of an open-source project.

Through this process of elimination, the git-annex team gained a new, albeit unexpected, benefit: a clear map of the actual quality of their dependency libraries. By stripping away the AI-generated noise, they were able to see which libraries were maintained with rigor and which were crumbling under the weight of automated contributions. This data now serves as the primary filter for future library adoption, shifting the criteria from feature-completeness to long-term maintainability.

GitHub Copilot and similar tools have made automated generation a daily habit for millions. Yet, the act of removing 10,000 lines of AI code from a 26,000-line project is a stark warning that the cost of maintenance does not vanish just because the cost of generation has dropped to zero.

Sustainability in software is determined by the ability to maintain code over decades, not the ability to generate it in seconds.