From Social Coding to Agentic Coding: Productivity and Relational Reconfiguration in Open-Source Communities

Coding Agents Boost Productivity but Threaten Open-Source Public Knowledge and Collaboration

Open-source software (OSS) is more than a collection of code. It is a form of digital public infrastructure built on visible collaboration. Traditionally, developers build these systems through open interactions. They use pull requests, code reviews, and public discussions. This creates a searchable, communal archive of how problems are solved. However, the rise of generative coding agents (CAs)—AI tools that automate task understanding and code generation—threatens this model. These tools shift activities from public human interaction to private human–agent loops. Researchers used a computer simulation of a real software community to study this shift. They found that while AI helps people finish tasks faster, it also makes people talk to each other less. It also leaves behind fewer useful public records for others to learn from.

The Visibility Gap in Modern Development

The strength of the open-source model relies on transparency. When a developer solves a bug, the trail of reasoning is typically laid bare. This happens in public issue threads and commit histories. This creates a "relational infrastructure" (the web of interpersonal connections and shared knowledge). This infrastructure allows newcomers to learn project norms. It also helps veteran developers distribute work.

Current research into coding agents focuses on the individual. It looks at how much faster a single programmer can write a function. But this narrow view ignores community-level consequences. Coding agents often operate within a developer's private workspace. Consequently, the intermediate steps of reasoning remain invisible. The iterative refinements stay hidden from the rest of the community. This creates a fundamental tension. We are gaining technical efficiency at the possible expense of collective intelligence.

Simulating a Digital Commons

To investigate this, the authors developed an LLM-based multi-agent simulation. This model mimics the complex social structures of GitHub. The researchers used a framework called AgentSociety to power developer agents. These agents use Large Language Models (LLMs) to exhibit context-sensitive behaviors.

The methodology followed a three-stage pipeline :

1. Initialization: The researchers selected 1,084 active developers from real GitHub data. They constructed "agent profiles" using quantitative data and qualitative biographies. They even applied Innovation Diffusion Theory (IDT) to categorize developers. This theory classifies users by their likelihood to adopt new tools, such as "Innovators" or "Laggards."
2. Warmup: To ensure realistic behavior, the researchers used "few-shot in-context learning" (providing a few examples to guide the model). They injected four weeks of real historical activity into the agents' memories. This allowed agents to adopt the recent project contexts of the actual humans they simulated.
3. Simulation: The community was branched into two parallel worlds. One was a "No-CA" condition (the baseline). The other was a "CA" condition, where coding agents were introduced. The simulation ran for four weeks. It tracked how AI altered task execution and social ties.

The Productivity–Knowledge Tension

The results confirm that coding agents are powerful engines of technical throughput. However, they come with significant social costs. The authors report that CAs substantially boosted productivity. Completed tasks increased by 39.0%. The median time to complete a task fell from 45 minutes to just 20 minutes .

This means developers can finish nearly twice as many tasks in the same timeframe.

However, these gains are not democratically distributed. The study finds that CA adoption reached only 26.0% of the community. Furthermore, the productivity benefits were concentrated among developers who were already highly active and well-connected .

This suggests a "participation amplifier" effect. AI may widen the gap between elite contributors and the rest of the community.

Most critically, the research highlights a reconfiguration of how work is done. In the baseline condition, direct human-to-human interaction (HHI) accounted for 32.4% of tasks. Under the CA condition, this dropped to 11.6% .

Instead, work shifted toward "agent-assisted self-loops" (ASA). These are tasks where a developer works entirely through private interaction with an agent. Work also moved to "agent-mediated interaction" (AHI), where the agent facilitates cross-developer tasks .

This shift into private loops harms the "public memory" of the project. The authors measured the usefulness of public records like commits and issues. While the real-human corpus achieved 81.1% knowledge coverage, the CA-generated corpus achieved only 22.3%. Finding relevant information became much harder. It required an average of 8.02 retrieval steps. This is a massive increase compared to the 2.63 steps required in the human-centric baseline.

Limits of the Synthetic Laboratory

The simulation is sophisticated, but it has limits. The authors note several inherent constraints. First, the simulation uses a fixed developer population. In real communities, people join and leave constantly. This churn fundamentally shapes long-term social dynamics. Second, the 8-week observation window is short. It may capture immediate shifts but cannot account for long-term decay of community norms.

Finally, the model does not account for certain real-world frictions. It does not model rejection, rollbacks, or merge conflicts. In the simulation, submitted commits are treated as accepted after review. In the real world, the struggle to get code accepted is vital. That struggle is often where the most valuable public knowledge is generated.

The Verdict: Proceed with Caution

Is agentic coding a net positive? The answer depends on your metric. If the goal is pure code throughput, the answer is yes. But if the goal is the long-term health of the open-source ecosystem, the outlook is more precarious.

The research suggests we are entering an era of "agentic coding." Here, the visible, social aspect of development is being hollowed out. We are trading communal learning for the speed of private, automated execution. For practitioners, the takeaway is clear. As AI tools become ubiquitous, we must protect the "why" behind the code. We must ensure that reasoning does not vanish into private agent chats. Success will require new ways to capture the knowledge that agents currently keep to themselves.

Figures from the paper