AI 编程工具正在大幅缩短开发者写代码的时间，但开源社区可能正在为这种效率提升付出另一种代价。
10 月 20 日，Linux 基金会发布最新研究报告《Navigating Open Source Software Development in the Generative AI Era》，调查生成式 AI 对开源软件开发、代码贡献和社区维护的影响。
报告给出了一组颇具反差的数据：受访者估计，使用生成式 AI 后，代码编写任务的平均耗时减少了 52%；与此同时，开源项目维护者估计，收到的 Pull Request（PR，拉取请求）中约有 25% 属于低质量贡献，被称为“AI slop”（AI 垃圾内容）。在大型开源项目中，这一比例进一步上升至 31%。59% 的维护者表示，自生成式 AI 兴起以来，项目收到的代码贡献数量有所增长；在大型项目中，这一比例达到 69%。
AI 正在让提交代码变得越来越容易，但维护者能否跟上代码增长的速度，成为新的问题。
AI 写代码更快了，复杂任务却未必省时间
Linux 基金会这份研究由 LF Research 发布，获得 Red Hat 赞助，以及 Futurewei、OpenSSF、LF AI & Data 的支持。
Linux 基金会在官方新闻中表示，生成式 AI 对开源开发效率的提升已经覆盖多个环节，远不止代码生成。在研究涉及的六类开源开发活动中，受访者均报告了不同程度的时间节省。其中，代码编写的平均耗时降幅最大，达到 52%；即使是提案讨论等沟通性任务，也实现了约 19% 的时间节省。
不过，这种效率提升并不适用于所有场景。对于复杂度较高的任务，21% 的受访者表示，使用生成式 AI 反而需要花费更多时间。这意味着，AI 在生成代码、处理常规开发任务时表现出的效率优势，未必能够直接转化为复杂软件工程任务的整体效率提升。
节省下来的时间也并没有全部转化为更多代码产出。66% 的受访者表示，他们将效率收益投入技术债务治理，63% 用于开发新功能，58% 用于学习和技能提升。
这些数据表明，AI 工具正在改变开发者的时间分配方式。但开发者个人效率的提高，并不意味着整个开源协作流程都能获得同等幅度的收益。
四分之一的 PR 被认为是“AI 垃圾”，维护者压力增加
相比代码编写效率，报告中更值得关注的是开源维护环节正在承受的压力。
59% 的维护者报告代码贡献数量增加，但这些新增贡献并不都能直接转化为项目价值。根据维护者的估计，收到的 PR 中约四分之一属于低质量内容。在大型项目中，这一比例达到 31%。
这里的“AI slop”通常指质量较差、缺少充分验证，或者需要维护者投入大量精力才能判断其价值的 AI 辅助贡献。需要强调的是，这一比例来自调查受访者的估计，并非研究人员对 GitHub 等平台上的 PR 进行逐项检测后得到的客观统计，也不意味着所有低质量 PR 都能被确认由 AI 生成。
但这组数据反映出的维护压力值得重视。
过去，开发者需要花费相当多的时间理解项目结构、编写代码、运行测试，才能提交一份 PR。随着 AI Coding 工具普及，生成代码和提交修改的门槛明显降低。对于贡献者来说，提出一次代码修改可能只需要很短时间；对于维护者而言，判断这些代码是否正确、是否符合项目架构、是否引入安全问题，仍然需要投入精力。
尤其是在大型开源项目中，维护者还需要处理代码兼容性、长期维护成本、贡献者沟通以及项目治理等问题。
Linux 基金会在报告中指出，维护者倦怠已经成为大型开源项目最突出的担忧之一。
这一变化也让 AI Coding 的生产力问题出现了新的衡量维度：如果代码生成成本大幅下降，但代码验证、审查和维护成本没有同步下降，那么效率收益可能会在不同角色之间重新分配。
71%认为 AI 降低了开源门槛，但社区信任并未同步提升
AI 对开源社区的影响也存在另一组矛盾。
调查显示，71% 的维护者认同生成式 AI 降低了参与开源项目的门槛。这意味着更多缺少特定编程语言、框架或项目经验的开发者，有机会借助 AI 工具参与开源协作。
但与此同时，53% 的维护者不同意“生成式 AI 改善了社区信任”这一说法。
开源社区的协作依赖代码之外的许多因素。维护者不仅需要知道一段代码能否运行，还需要判断贡献者是否理解修改内容，能否解释设计选择，以及在后续出现问题时是否有能力继续维护。
AI 可以帮助开发者快速生成修改方案，却不能自动建立贡献者与维护者之间的信任。
报告还发现，46% 的维护者认为，生成式 AI 增加了对新贡献者进行指导的需求；32% 则认为这种需求有所减少。
这也说明，AI 虽然降低了新开发者进入开源社区的技术门槛，但新人仍然需要理解项目规范、协作流程和软件工程实践。部分原本用于指导代码编写的工作，可能正在转向代码验证、问题解释和贡献质量管理。
只有 35%的项目制定了正式 AI 贡献政策
面对 AI 辅助代码贡献的快速增长，开源社区的治理机制尚未完全跟上。
Linux 基金会的调查结果显示，只有 35% 的项目制定了正式政策，明确允许在代码贡献中使用生成式 AI。另有 32% 的项目既没有相关政策，也没有制定政策的计划。在贡献者一侧，61% 的受访者表示，他们会在提交 AI 生成代码之前进行详细审查和完整的功能测试。但 AI 使用情况的披露仍然缺乏一致标准。
这带来了一个现实问题：维护者收到一份代码贡献时，未必清楚其中哪些部分由 AI 生成、贡献者进行了哪些验证，以及代码修改是否经过充分测试。对于依赖志愿维护者的开源项目而言，这种信息不对称可能进一步增加审查成本。
Linux 基金会建议，开源项目应建立明确的 AI 辅助贡献政策，对代码测试、文档说明和 AI 使用披露提出要求，同时完善贡献归属与验证机制。OpenSSF 相关负责人也在官方发布的声明中强调，AI 可以加快代码编写，但贡献者仍然需要理解并测试自己提交的内容，维护者不应独自承担全部安全审查责任。
AI Coding 的效率红利，谁来承担验证成本？
过去两年，AI Coding 的讨论很大程度上围绕代码生成速度、任务完成率和开发者生产力展开。从代码补全到能够自主修改仓库、执行测试并提交 PR 的 Coding Agent，自动化能力正在不断增强。
Linux 基金会这份报告提供了另一个观察角度：当代码生产速度提升之后，软件工程流程中的瓶颈可能逐渐向审查、验证和维护环节转移。
这种变化对开源项目尤其明显。开源项目的代码贡献可以来自全球任何开发者，但维护权限通常集中在相对有限的核心维护者手中。AI 工具能够让更多人快速生成代码，却无法保证维护者的时间和精力以同样速度增长。
这并不意味着 AI 辅助贡献必然降低开源软件质量。报告同样显示，AI 正在降低参与门槛，帮助开发者偿还技术债务、开发新功能，并提升学习效率。
问题在于，随着 AI 生成代码成为常态，开源社区需要建立与之匹配的验证和治理机制。未来衡量 AI Coding 的价值，除了开发者节省了多少编码时间、Agent 完成了多少任务，还需要关注代码最终被接受的比例、审查所需的时间、缺陷修复成本，以及长期维护负担。
AI 让代码越来越容易生产，而让这些代码真正进入可靠的软件系统，仍然需要付出成本。
本文由 AI图鉴自动抓取并翻译，版权归原作者所有；如需查看原文请点下方链接。
AI programming tools are significantly reducing the time for developers to write codes, but open-source communities may be paying another price for this efficiency improvement.
On 20 October, the latest study by the Linux Foundation publish, Navigating Open Source Software Development in the General AI Era, investigated the impact of AI on open source software development, code contribution and community maintenance.
The report gives a very contrasting set of data: respondents estimate that the code-writing task of average latency has been reduced by 52 per cent following the use of the generated AI; at the same time, the Open Source Project maintainer estimates that about 25 per cent of the Pull Request (PR, pull requests) received are low-quality contributions, referred to as “AI slop” (AI garbage content). In large open source projects, this proportion further increased to 31 per cent. Fifty-nine per cent of the maintainers indicated that the number of code contributions received by the project had increased since the emergence of the Generation AI; in large projects, the percentage reached 69 per cent.
AI is making it easier to submit codes, but is it possible for the maintainer to keep up with code growth and become a new issue.
AI, writing codes is faster. Complex tasks don't necessarily take time.
The Linux Foundation research was sponsored by LF Research publish and supported by Red Hat and Futurewei, OpenSSF, LF AI & Data.
In the official news, the Linux Foundation stated that generation AI efficiency improvements in open-source development already cover multiple segments, much more than code generation. In the six categories of open source development covered by the study, respondents reported varying degrees of time savings. Of these, code preparation of average latency was the most significant reduction, reaching 52 per cent; even communication tasks such as proposal discussion achieved approximately 19 per cent time savings.
However, such efficiency gains do not apply to all scenarios. For more complex tasks, 21% of respondents said it would take more time to use the generated AI. This means that AI ' s efficiency advantages in generating codes and processing routine development tasks do not necessarily translate directly into overall efficiency gains for complex software engineering tasks.
The time saved has not been fully translated into more code outputs. Sixty-six per cent of respondents indicated that they invested efficiency gains in technical debt management, 63 per cent in the development of new functions and 58 per cent in learning and skills upgrading.
These data indicate that the AI tool is changing the time allocation of developers. However, improvements in the individual efficiency of developers do not mean that the benefits of the open-source collaborative process as a whole are equal.
A quarter of the PR is considered "AI trash" and maintenance pressure increases
More than the efficiency of code preparation, the report is more noteworthy in terms of the pressure being placed on open source maintenance.
The contribution of 59 per cent of the maintainers to the reporting codes increased, but not all of these added contributions were directly translated into project value. According to the defender ' s estimates, about a quarter of the PRs received were of low quality content. In large-scale projects, this proportion reached 31 per cent.
The term “AI slop” here usually refers to a complementary AI contribution of poor quality, lack of sufficient validation, or a significant amount of effort on the part of the maintainer to judge its value. It is important to emphasize that this percentage is estimated by respondents to the survey and is not the objective statistics obtained by researchers following an item-by-item test of PR on platforms such as GitHub, nor does it mean that all low-quality PRs can be identified as being generated by AI.
The maintenance pressure reflected in this set of data deserves attention.
In the past, developers had taken considerable time to understand the project structure, prepare codes and run tests before submitting a PR. With the spread of the AI Coding tool, the threshold for the generation of codes and the submission of changes is significantly lower. For the contributor, it may take a short time to propose a code change; for the maintainer, the determination of whether the codes are correct, consistent with the project structure, and whether to introduce security concerns still requires effort.
In particular, in large open-source projects, defenders also need to address code compatibility, long-term maintenance costs, donor communication and project governance.
In its report, the Linux Foundation noted that the fatigue of defenders had become one of the most prominent concerns of large open-source projects.
This change has also led to a new dimension of the productivity problem of AI Coding: If the cost of code generation falls significantly, but the cost of code validation, review and maintenance does not decline simultaneously, efficiency gains may be redistributed among different players.
71% believe AI has lowered the open source threshold, but community trust has not been raised simultaneously
There is another contradiction between AI ' s impact on open-source communities.
The survey showed that 71% of the maintainer identification generation AI lowered the threshold for participation in open source projects. This means that more developers lacking specific programming language, framework or project experience have the opportunity to engage in open-source collaboration using the AI tool.
At the same time, however, 53% of defenders disagree with the expression “genetic AI improves community trust”.
Collaboration among open-source communities relies on many factors beyond codes. Maintainers need not only to know whether a code is operational, but also to judge whether the contributor understands the changes, whether it can explain the design options and whether it is able to continue to maintain them in the event of subsequent problems.
AI can help developers quickly generate modifications, but does not automatically build trust between contributors and defenders.
The report also found that 46 per cent of the maintainers felt that the generation AI increased the need for guidance to new contributors, while 32 per cent felt that the demand had decreased.
This also suggests that AI, while lowering the technological threshold for new developers to enter open-source communities, still needs to understand project specifications, collaborative processes and software engineering practices. Part of the work used to guide code writing may be moving towards code validation, problem interpretation and contribution quality management.
Only 35% of projects have a formal AI contribution policy
The governance mechanisms of open-source communities are not yet fully up to date in the face of the rapid growth of AI support code contributions.
The Linux Foundation ' s findings show that only 35 per cent of projects have formal policies that explicitly allow the use of generated AI in code contributions. A further 32 per cent of the projects had neither a policy nor a policy plan. On the contributor side, 61 per cent of respondents indicated that they would conduct a detailed review and complete functional testing before submitting the AI generation code. However, AI disclosure of usage still lacks consistent standards.
This raises a practical question: when the maintainer receives a code contribution, it is not necessarily clear which parts of the code are generated by AI, what validation the contributor has conducted, and whether the code changes have been adequately tested. This information asymmetry may further increase the cost of review for open-source projects that rely on voluntary defenders.
The Linux Foundation recommends that open-source projects establish a clear AI Auxiliary Contribution Policy that requires disclosure for code testing, document description and AI use, while improving attribution and validation mechanisms for contributions. In a statement issued by the official publish, the relevant official of OpenSSF also stressed that AI could speed up code writing, but that the contributor still needed to understand and test the content it submitted and that the defender should not be alone in taking full responsibility for security clearance.
AI Coding efficiency dividend, who will bear the cost of certification?
Over the past two years, AI Coding has been largely focused on the speed of code generation, mission completion rates and developer productivity. From code completion to the ability to independently modify the warehouse, perform testing and submit PR, automation is increasing.
The Linux Foundation report provides another perspective: As the speed of code production increases, bottlenecks in software engineering processes may gradually shift to review, validation and maintenance.
This change is particularly evident for open source projects. The code contribution of open-source projects can come from any developer around the globe, but maintenance of permission is usually concentrated in relatively limited core maintainers. AI tools enable more people to generate codes quickly, but do not guarantee that the time and energy of the maintainer grow at the same rate.
This does not mean that AI support contributions necessarily lower the quality of open source software. Similarly, the report indicates that AI is lowering the threshold for participation, helping developers to repay their technical debt, developing new functions and improving learning efficiency.
The problem is that, as AI generation codes become normal, open-source communities need to have mechanisms for validation and governance that match them. Future measurement of AI Coding ' s value, in addition to the amount of coding time saved by developers, the amount of tasks performed by Agent, requires attention to the percentage of code eventually accepted, the time required for review, the cost of repairing defects, and the burden of long-term maintenance.
AI makes codes easier to produce, and there is still a cost involved in getting them into a reliable software system.
Auto-fetched and translated by AI Atlas. All rights belong to the original author.