Linux Foundation Report: AI Speeds Coding but Degrades Open Source PR Quality

Generative AI has significantly improved code-writing efficiency (reducing average time by 52%), but it has simultaneously triggered a decline in Pull Request (PR) quality. In large open-source projects, approximately 31% of PRs are classified as low-quality "AI slop." Maintainers face dual pressures: a surge in contribution volume (+69% in large projects) and an increased review burden.

While AI accelerates simple coding tasks, it does not significantly shorten the cycle for complex ones; low-quality PRs increase maintenance costs rather than reduce them; and the growth in contributions has not translated into effective collaboration improvements.

This article is suitable for open-source project maintainers, technical leads, and DevOps engineers.

AI programming tools are drastically reducing the time developers spend writing code, but the open-source community may be paying a different price for this efficiency gain.

On October 20, the Linux Foundation released its latest research report, Navigating Open Source Software Development in the Generative AI Era, investigating the impact of generative AI on open-source software development, code contributions, and community maintenance.

The report presents a set of contrasting data points: respondents estimated that using generative AI reduced the average time required for code-writing tasks by 52%. Meanwhile, open-source project maintainers estimated that approximately 25% of incoming Pull Requests (PRs) were low-quality contributions, termed "AI slop." In large open-source projects, this proportion rose to 31%. Furthermore, 59% of maintainers reported an increase in code contributions since the rise of generative AI; in large projects, this figure reached 69%.

AI is making submitting code increasingly easy, but whether maintainers can keep up with the speed of code growth has become a new challenge.

AI speeds up code writing, but complex tasks may not save time

This study by the Linux Foundation was published by LF Research, sponsored by Red Hat, and supported by Futurewei, OpenSSF, and LF AI & Data.

In an official press release, the Linux Foundation stated that the efficiency gains from generative AI in open-source development extend beyond just code generation, covering multiple stages of the workflow. Across six categories of open-source development activities studied, respondents reported varying degrees of time savings. Code writing saw the largest reduction in average time, at 52%; even communicative tasks like proposal discussions achieved approximately 19% time savings.

However, these efficiency gains do not apply to all scenarios. For highly complex tasks, 21% of respondents indicated that using generative AI actually required more time. This suggests that the efficiency advantages AI demonstrates in generating code and handling routine development tasks do not necessarily translate directly into overall efficiency improvements for complex software engineering tasks.

Moreover, the saved time has not been entirely converted into increased code output. 66% of respondents stated they invested the efficiency gains in addressing technical debt, 63% used it for developing new features, and 58% dedicated it to learning and skill enhancement.

These data indicate that AI tools are changing how developers allocate their time. However, improved individual developer efficiency does not imply that the entire open-source collaboration process benefits equally.

A quarter of PRs deemed "AI slop," increasing maintainer pressure

More noteworthy than code-writing efficiency is the growing strain on open-source maintenance highlighted in the report.

59% of maintainers reported an increase in code contributions, but not all new contributions directly translate into project value. According to maintainer estimates, about one-quarter of received PRs are low-quality content. In large projects, this proportion reaches 31%.

"AI slop" typically refers to AI-assisted contributions that are poor in quality, lack sufficient validation, or require significant effort from maintainers to assess their value. It is important to note that these proportions are based on survey respondent estimates, not objective statistics derived from researchers individually inspecting PRs on platforms like GitHub. Nor does it imply that all low-quality PRs can be confirmed as AI-generated.

Nevertheless, the maintenance pressure reflected in this data deserves serious attention.

Previously, developers needed to spend considerable time understanding project structures, writing code, and running tests before submitting a PR. With the proliferation of AI Coding tools, the barrier to generating code and submitting changes has dropped significantly. For contributors, proposing a code change may take very little time; however, for maintainers, determining whether the code is correct, aligns with the project architecture, or introduces security issues still requires substantial effort.

Especially in large open-source projects, maintainers must also handle issues related to code compatibility, long-term maintenance costs, contributor communication, and project governance.

As noted in the Linux Foundation's report, maintainer burnout has become one of the most prominent concerns in large open-source projects.

This shift introduces a new dimension for measuring the productivity of AI Coding: if the cost of code generation drops dramatically while the costs of code verification, review, and maintenance do not decrease correspondingly, efficiency gains may simply be redistributed among different roles.

71% believe AI lowers barriers to entry, but community trust hasn't kept pace

There is another contradiction regarding AI's impact on the open-source community.

The survey shows that 71% of maintainers agree that generative AI has lowered the barrier to participating in open-source projects. This means developers lacking specific programming language, framework, or project experience now have opportunities to participate in open-source collaboration with the help of AI tools.

However, simultaneously, 53% of maintainers disagree with the statement that "generative AI has improved community trust."

Collaboration in open-source communities relies on many factors beyond just code. Maintainers need to know not only if a piece of code runs, but also whether the contributor understands the modifications, can explain design choices, and has the capability to continue maintaining the code if issues arise later.

AI can help developers quickly generate modification proposals, but it cannot automatically establish trust between contributors and maintainers.

The report also found that 46% of maintainers believe generative AI has increased the need for mentoring new contributors, while 32% feel this demand has decreased.

This indicates that although AI lowers the technical barrier to entry for new developers joining open-source communities, newcomers still need to understand project conventions, collaboration workflows, and software engineering practices. Some tasks originally dedicated to guiding code writing may be shifting toward code verification, issue explanation, and contribution quality management.

Only 35% of Projects Have Formal AI Contribution Policies

In the face of rapidly growing AI-assisted code contributions, governance mechanisms in open-source communities have not fully caught up.

According to Linux Foundation survey results, only 35% of projects have established formal policies explicitly permitting the use of generative AI in code contributions. Another 32% of projects have neither such policies nor plans to create them. On the contributor side, 61% of respondents stated they conduct detailed reviews and comprehensive functional testing before submitting AI-generated code. However, there remains a lack of consistent standards for disclosing AI usage.

This creates a practical problem: when maintainers receive a code contribution, they may not know which parts were generated by AI, what verification steps the contributor took, or whether the code modifications were thoroughly tested. For open-source projects relying on volunteer maintainers, this information asymmetry can further increase review costs.

The Linux Foundation recommends that open-source projects establish clear policies for AI-assisted contributions, setting requirements for code testing, documentation, and AI usage disclosure, while improving attribution and verification mechanisms for contributions. Representatives from OpenSSF also emphasized in an official statement that while AI can accelerate code writing, contributors must still understand and test what they submit, and maintainers should not bear the sole responsibility for all security reviews.

Who Bears the Verification Cost of AI Coding Efficiency Gains?

Over the past two years, discussions around AI Coding have largely focused on code generation speed, task completion rates, and developer productivity. From code completion to Coding Agents capable of autonomously modifying repositories, executing tests, and submitting PRs, automation capabilities are continuously strengthening.

This Linux Foundation report offers another perspective: as code production speeds increase, bottlenecks in the software engineering process may gradually shift toward review, verification, and maintenance stages.

This change is particularly evident in open-source projects. Code contributions can come from any developer worldwide, but maintenance privileges are typically concentrated among a relatively limited group of core maintainers. AI tools enable more people to generate code quickly, but they cannot guarantee that maintainers' time and energy will grow at the same pace.

This does not mean that AI-assisted contributions necessarily reduce open-source software quality. The report also shows that AI is lowering participation barriers, helping developers pay down technical debt, develop new features, and improve learning efficiency.

The challenge lies in the fact that as AI-generated code becomes the norm, open-source communities need to establish verification and governance mechanisms that match this reality. In the future, measuring the value of AI Coding will require looking beyond how much coding time developers save or how many tasks agents complete; it will also involve tracking the final acceptance rate of code, the time required for reviews, defect remediation costs, and long-term maintenance burdens.

AI makes code increasingly easy to produce, but integrating that code into reliable software systems still incurs significant costs.