New GitHub Copilot research finds 'downward pressure on code quality'
New research from GitClear suggests that GitHub Copilot and similar AI coding assistants are correlated with more churn, duplicated code, and reduced adherence to practices like DRY, raising concerns about long‑term code quality. Commenters describe AI tools as highly effective for boilerplate, tests, and “getting started,” but note that they often produce subtly wrong or naive solutions that are hard to debug, especially for less experienced developers. Others question the study’s methods and argue that the real issue is how teams use these tools and what they optimize for, warning that incentives around speed and lines of code may amplify the downsides.
Perceived impact on code quality and churn
- Many commenters say Copilot/LLMs increase “just‑OK” code, copy‑paste, and churn, often violating DRY and creating future tech debt.
- Several describe real incidents where heavy AI use led to fragile production code, last‑minute rewrites, and firefighting.
- Others argue that lower quality can be acceptable when the task itself is simple or short‑lived, and that not all churn is “defective” – it can reflect cheaper experimentation.
Study methodology and limits
- The linked research is seen as interesting but methodologically weak: it infers correlations from repo metrics without directly knowing which code was AI‑generated.
- Some point out the regression used very few data points and didn’t control for other factors (e.g., COVID hiring/layoffs, tech economy shifts).
- Even sympathetic readers stress it cannot show causality, only that 2023 looks different from earlier years.
How developers use AI tools
- Popular “good” uses: boilerplate, boring config, repetitive refactors, tests, docstrings, commit messages, simple SQL, OpenAPI specs, one‑line autocompletion.
- Several treat LLMs as a “smart rubber duck” or better search: ask questions, sanity‑check docs and APIs, refine designs.
- Many find Copilot poor for complex logic, deeper architecture, or non‑trivial SQL; reviewing its output can exceed the cost of writing code yourself.
Learning, juniors, and skill drift
- Strong concern that juniors will “press tab” instead of learning, becoming dependent on AI and unable to judge code quality.
- Others counter that LLMs can be powerful tutors, if you already know enough to critique answers and use them to clarify concepts.
Productivity, incentives, and craftsmanship
- Some report clear productivity gains and happily accept slightly worse code for faster outcomes; others cancel subscriptions because debugging AI output costs more.
- Several tie this to broader trends: pressure for higher output with stagnant pay, management tracking LOC/velocity, and a shift from “craftsman” to “laborer” style programming.
- Debates arise around DRY/SOLID and abstractions: some blame over‑DRY and patterns for complexity; others argue they remain essential for maintainability, especially as AI makes it cheap to generate masses of code.
Broader concerns and analogies
- Comparisons are drawn to calculators, spell‑check, the internet, and even writing itself: every new tool was once said to make people “dumber.”
- Some fear long‑term erosion of unassisted human skill and a feedback loop where AI‑generated code degrades future training data.
- Others see AI as early, over‑hyped, but ultimately just another tool whose net impact will depend on how humans adapt workflows, testing, and incentives.