The myth of software is the kid in the garage. Jobs and Wozniak. Gates and Allen. Zuckerberg in a dorm. The story we tell about how things get built is a story about lone genius.
That myth was always wrong.
Software, at its best, was never made alone. It was made together, in public, with strangers. A pull request was a conversation. A code review was a debate. An issue thread was an argument about the right way to solve a problem, and the argument was often more valuable than the code. The Linux kernel wasn’t a product. It was a community holding a discussion that happened to produce an operating system.
That commons is now eroding. Not through scandal or collapse, but through something quieter — closer to what Robert Putnam described a quarter-century ago: the activity remains, but the institutions around it thin out.
The Bowling Alone Moment
Putnam’s most counterintuitive observation in Bowling Alone was that Americans hadn’t stopped bowling. They had stopped bowling in leagues. The individual act persisted. The communal scaffolding disappeared.
Software is entering its own bowling-alone moment. Developers are writing more code than ever, with astonishingly capable tools. But the forums, public repositories, mailing lists, issue threads, code reviews, and informal conversations that surrounded that work are thinning. The output looks healthy. The social layer is eroding.
I have felt this shift in my own work. The first time an AI coding assistant helped me untangle a problem that would once have sent me into a maze of tabs and forum posts, I felt the obvious thrill: speed, fluency, relief. The answer arrived without the ritual of searching, lurking, comparing, and slowly triangulating a solution from the traces other people had left behind.
But after that relief came a stranger feeling. The problem had been solved, but nothing had been added to the world. No question improved. No answer refined. No breadcrumb left for the next person. The exchange was useful, but sterile.
This is not an argument against AI. I use it constantly, and my work is better for it. The question is what happens to one of the most collaborative professions on the internet when more of its work becomes a single-player game.
The developer using Cursor or Claude Code is not alone in the old sense. They are in constant dialogue: asking, clarifying, revising. But the dialogue is private and unreciprocated. It solves the immediate problem while producing no public residue — no searchable thread, no comment history, no trace of the judgment that led from one approach to another.
The work gets done. The commons does not get replenished.
The Middle Ring
Putnam alone undersells what is being lost. The sharper frame comes from Marc Dunkelman’s The Vanishing Neighbor: we have not lost all relationships. We have lost a specific kind.
The inner ring of close family and friends remains strong. The outer ring of broadcast audiences on social media has grown. What has collapsed is the middle ring — people, in Dunkelman’s words, “not as close as kith or kin, but not as distant as a mere acquaintance.”
That phrase describes what software culture once produced in abundance. Not friendship. Not audience. Useful strangers: the Stack Overflow stranger at 2 a.m., the open-source co-maintainer in another time zone, the senior engineer whose blog post taught me something years later.
The useful stranger is easy to underestimate because the relationship is so light. There is no standing meeting, no org chart, no formal responsibility. But enough of those light relationships create a profession. They create the sense that someone has probably seen your problem before, that the answer might already be out there, and that if you solve something obscure, you owe the next person a note.
That obligation was never evenly distributed or perfectly honored. The old commons had plenty of gatekeeping, status games, and exhaustion. But it also carried a moral assumption that now feels fragile: technical knowledge improves when it is made public, contested, corrected, and reused.
That middle layer is where much of my professional development happened. It is also the layer AI most easily displaces — not because AI is worse at answering a question, though often it is better, but because the question was never only about the answer. It was about entering a community of practice.
I recognize this in my own life because so much of what I learned about technology came from people I never really knew. I learned from documentation written with care by someone who would never meet me. I learned from forum replies written for someone else’s problem that happened to be mine three years later. I learned from the tone of maintainers: the terse ones, the generous ones, the ones who had clearly answered the same question a hundred times and still found a way to be useful.
These were not intimate relationships, but they were not nothing. They were part of the moral atmosphere of the web. They taught a quiet lesson: knowledge is something you receive and then leave behind in better condition for the next person.
The early web inverted a long-standing rule: building anything significant used to require institutional permission. Then a teenager could open a pull request against a senior engineer at Google, argue about API design, and sometimes win. Status came from contribution. Reputation accumulated in public.
That produced more than code. It produced institutions — open source, Wikipedia, the IETF, Stack Overflow, Code for America — among the most functional of the early 21st century.
Pull requests and issue threads did not merely produce code; they taught people how software communities reasoned in public. They produced maintainers, reviewers, documenters, and teachers.
The visible artifact was code. The invisible output was a shared culture of judgment.
A person learned what a good bug report looked like. How to ask a question without wasting other people’s time. Why backward compatibility was moral as much as technical. Why “working” was not the same as “ready.” Why cleverness was not the same as stewardship.
AI can explain these things. But explanation is different from participating in the practices that sustain them.
That is part of what I fear we are losing: not knowledge, exactly, but the public context around knowledge. A developer can now receive a good explanation without watching a person reason toward it. They can get the answer without seeing the norm. They can learn the pattern without joining the practice.
The work has changed.
The Single-Player Turn
Pair programming — one driver at the keyboard, one navigator thinking out loud — was a canonical ideal in important parts of software culture. Two minds catch what one misses, and explaining your thinking to another human forces you to understand it.
AI increasingly occupies the place once held by the second human. The driver is still there. The navigator is now a model.
That is the deepest shift. The form of collaboration remains, but the social relationship changes. The second voice can help, suggest, correct, and explain. But it does not belong to the same community. It has no stake in the project. It cannot be embarrassed by a bad decision, disappointed by a careless one, or proud of the thing you maintained together.
When the second voice is a model, you don’t post the disagreement to Stack Overflow, because there was no disagreement to post. You don’t open an issue thread, because the issue was resolved in chat. You don’t write the blog post afterward, because the conversation already feels complete.
The shift is subtle because the experience still feels social. A good AI coding session can feel like pairing with someone tireless, patient, and unusually well read. It lowers embarrassment. You can ask the naive question without worrying that someone will judge you. You can paste the ugly error, the half-baked function, the thing you should probably already know. In that sense, the model is humane.
But the old public process forced a kind of translation. You had to turn your private confusion into a question someone else could understand. You had to describe the environment, the constraint, the error, the thing you had tried. That was tedious, but it was also clarifying. Many developers have had the experience of solving a problem while writing the question, because making the problem legible to others made it legible to themselves.
AI short-circuits that ritual. Often, that is wonderful. It saves time and lowers the emotional tax of asking for help. But it also removes the public act of clarification. The question is no longer improved on the way to becoming shared. It is consumed privately by a system that has no need for the next person to understand what happened.
But shame was not the only thing at stake in public learning. Public learning also created obligation. When you asked a question in public, you had to make it intelligible. When someone answered, they were not merely serving you; they were leaving something for everyone else. The exchange created a small piece of shared infrastructure.
A peer-reviewed study in Nature Scientific Reports found that Stack Overflow traffic “declined by approximately 1 million individuals per day” after ChatGPT’s release, with no equivalent decline on Reddit’s developer communities. The authors attributed the contrast to social fabric. Relationships defined purely by information exchange are the most replaceable. Communities with thicker social fabric survive.
Stack Overflow question volume is down roughly 76% from its 2017 peak. 81.5% of GitHub contributions happen in private repositories. Different phenomena, same direction: more software work is happening away from public, searchable, socially governed spaces.
Some public spaces are not merely emptying; they are hardening. Maintainers at projects like cURL and Godot are increasingly buried in low-quality AI-generated submissions. The commons becomes less useful not only when people leave, but when participation becomes too noisy to govern.
There is a temptation to treat this as an inevitable trade: more access in exchange for less community. I do not think that is right. The democratizing promise of AI is real precisely because the old system had barriers. Not everyone had access to elite teams, patient mentors, or permissive workplaces where learning in public was safe. For many people, a private model is less intimidating than a public forum and more available than a senior colleague. That matters.
But the fact that AI solves one access problem does not mean it solves the social problem. It may help someone enter the craft while giving them fewer reasons to enter the community. That is the paradox: the tool can lower the cost of participation in software while raising the likelihood that participation happens alone.
The democratizing wins are real. Solo founders, nonprofits, and junior developers can now build things that previously required teams or budgets. But the cost is social. Output may improve even as the connective tissue weakens.
What Has Changed in the Market
- AI coding has moved from autocomplete to agents. The market is no longer just helping developers finish lines of code; it is moving toward tools that can plan, edit, test, and submit larger changes.
- The bottleneck is shifting from writing to reviewing. As code gets cheaper to produce, judgment becomes more valuable: architecture, security, maintainability, and accountability.
- Private development is becoming the default. More software work is happening inside private repositories, private chats, and enterprise platforms rather than public forums and open threads.
- Public Q&A is weakening as shared infrastructure. Stack Overflow’s decline is not just a traffic story; it signals a move away from searchable, communal problem-solving toward private answers.
- Open source is absorbing new noise. AI lowers the cost of contribution, but also the cost of low-quality issues, pull requests, and suggestions that maintainers still have to review.
- The labor market is reorganizing around leverage. Junior developers, solo founders, and domain experts can build more, but the premium shifts toward taste, judgment, context, and responsibility for what gets shipped.
- The moat is moving away from code alone. Durable value will come from distribution, trust, proprietary context, workflow integration, security, and the ability to maintain software over time.
Taken together, these market shifts reinforce the cultural one. AI is not simply another productivity tool inside the old software economy. It changes where value accumulates. If code becomes easier to produce, the scarce things become harder to fake: knowing what should be built, understanding the domain, judging whether the output is safe, and maintaining the thing after the demo works.
That should make the social layer more valuable, not less. Review, trust, shared standards, and institutional memory are precisely the things that become more important when the cost of generating plausible code falls. The danger is that the market rewards the visible acceleration while underpricing the slower systems that make acceleration safe.
The irony is that AI feels conversational, but it is not communal. It gives back the feeling of dialogue while removing the experience of being answerable to another person. That distinction matters. A model can challenge you, but it cannot be disappointed in you. It can critique your code, but it cannot ask whether you have considered the maintainer who will inherit it. It can simulate judgment, but it does not share a world with you.
The Reservoir
The models that make private development so seamless were trained on the public commons of the pre-ChatGPT web — the mailing list arguments, issue threads, Stack Overflow answers, and blog posts where senior developers thought out loud. That commons taught the models. The models now answer the questions privately. The public record that would have trained the next generation — of models, and of developers — is no longer being written in the same way.
We are drawing down a reservoir we are not refilling.
The reservoir metaphor matters because it names a timing problem. For now, AI feels abundant because it is drawing on decades of accumulated public knowledge. The answers are good because the old web was noisy, argumentative, and generous enough to leave a record. But if future problem-solving moves into private chats, the stock keeps being used while the flow weakens.
This does not mean the commons disappears overnight. It means it becomes stale. The public web may continue to explain older frameworks, older patterns, older errors, and older ways of thinking, while the frontier moves into private workspaces. A profession can still function that way for a while. But over time, the shared map gets worse. The newest lessons are learned somewhere, by someone, but not in places where others can find them.
What made the old commons powerful was not simply that information was available. It was that information arrived with context. You could see the wrong turns, the competing proposals, the impatient correction, the gracious follow-up, the eventual consensus. A good thread did not only answer the question at hand. It revealed how practitioners judged tradeoffs. It showed what counted as evidence, what counted as taste, and what counted as responsibility.
That kind of learning is hard to measure because it rarely announces itself. It happens slowly, through exposure. You read enough issue threads and begin to understand what maintainers care about. You watch enough pull requests get rejected and begin to understand why maintainability matters. You see enough experienced developers choose boring solutions and begin to understand that restraint is a form of expertise.
The risk is not isolation. Developers are not necessarily lonely; many are happier and more productive than ever. The risk is quieter: fewer weak ties, less ambient learning, a thinner shared culture.
AI can help a junior developer get unstuck. But it does not embarrass you gently in public, make you defend a design choice to a maintainer, or teach you how to disagree with a peer without blowing up the project. It does not make you wait for someone else’s review. It does not ask you to become accountable to a group.
Those were not just inefficiencies. They were part of how the culture reproduced itself.
The question, then, is not whether AI will make developers more productive. It will. The question is what we will do with the time, attention, and capacity it frees up. One possibility is that we simply ship more. More features, more prototypes, more pull requests, more half-maintained tools. Another possibility is that we use some of that surplus to rebuild the social infrastructure that made software worth belonging to in the first place.
Rebuilding the Leagues
The most useful thing about Putnam’s later work, The Upswing, is that it refuses fatalism. Civic infrastructure is not inherited. It is built.
Software’s “we” period was built too. Open-source norms, code review culture, Stack Overflow, hackathons, civic tech brigades — none of them were inevitable. If they are eroding, the answer is not nostalgia. It is institution-building.
Engineering culture was never overhead. It was the substrate that produced trust networks and shared norms. Treating it as friction to be optimized away is a category error.
Rebuilding the leagues does not mean recreating 2012 Stack Overflow or pretending open source can run forever on heroic volunteer labor. It means designing new defaults: teams that make AI-generated work reviewable, communities that reward explanation, and institutions that help newcomers become contributors rather than merely users of increasingly powerful tools.
Hackathons, pair programming, open source, and code review become more valuable, not less, because they preserve something AI does not automatically provide: a reason to be accountable to other people.
This is especially true in civic tech, where the point was never only to ship products. The brigade, the hack night, the open data portal, the public GitHub repo — these were invitations. They told people that government and technology were not sealed systems. They could be entered, questioned, improved.
That lesson feels newly important. AI can make a single person much more capable, but capacity is not the same as legitimacy. Trust is not generated by private productivity. It is generated by repeated participation in shared work.
In the old world, the work produced the commons. In the new one, the commons will have to be built on purpose.
People are still bowling. The leagues will only come back if someone builds them.
