What Happens to Open Source When Humans Stop Writing the Software?
In 2023, I was invited and hosted by the Linux Foundation in Geneva for the Open Source Congress.
It was an invitation-only gathering of open source leaders from across the ecosystem. Fifty-three leaders representing 37 organizations came together to discuss some of the biggest challenges facing open source: security, regulation, global collaboration, governance, and AI.
One of the sessions had a simple question for a title:
Does AI Change Everything?
Looking back at that question now, in 2026, it means something very different to me.
Because AI did change a lot.
Just not exactly in the way we were thinking about it then.
Before Geneva
My own thinking around this started even earlier.
In 2022, I was already experimenting with GitHub Copilot and thinking about what AI-assisted development would mean for how developers build software.
At the time, Copilot felt almost magical.
You started writing code and suddenly the machine understood where you were going.
A function that might take a while to write could appear in seconds.
But it still felt very clearly like an assistant.
I was coding.
Copilot was helping me code.
The human was still at the centre of the process.
By 2023, when we gathered in Geneva, the questions had already become much bigger.
What does open mean for AI?
What does transparency mean?
Where does AI-generated code come from?
How do licences apply?
What happens with copyright?
Can the same ideas and definitions we built for open source software simply be transferred to AI?
The report that came out of the 2023 Open Source Congress captured that tension directly. It noted that the traditional protocols and definitions of open source do not transfer seamlessly to AI systems, and asked whether access to source code alone is enough for something to be considered open.
Read the 2023 Open Source Congress report
At the same time, another part of the conversation was already beginning to appear.
Software development itself was changing.
We knew AI was going to change how software gets built
The 2023 report discussed tools like GitHub Copilot and OpenAI Codex and how natural-language prompts could already generate complete functions in seconds.
At that time, a lot of the concern was around provenance, licensing, security, and regulation.
If these models were trained on huge amounts of open source code, where exactly did the generated code come from?
What licence applied?
Could vulnerabilities from existing codebases reappear in AI-generated software?
Could an AI system accidentally reproduce something proprietary?
Those were real questions then, and they remain real questions now.
But the report made another observation that feels even more important in hindsight: AI was changing the way developers generate open source code.
Three years later, I think that sentence goes much further than we understood at the time.
Because we are no longer only talking about AI generating code.
We are increasingly talking about AI doing software development.
Then I received another invitation
In 2026, I was invited again to the Open Source Congress.
I missed it.
But receiving that invitation was one of the things that made me start thinking seriously about this article.
It brought me back to Geneva.
To the discussions in 2023.
To Copilot in 2022.
To the work happening around defining Open Source AI.
And then I compared all of that with how software is being built today.
Somewhere between those two invitations, the question changed for me.
In 2023, we were asking:
What happens when AI generates open source code?
In 2026, I think we also need to ask:
What happens to open source when AI increasingly does the work that brought humans into open source in the first place?
That is a different question.
Open source was designed around people
For most of open source history, there has been an assumption underneath how the ecosystem works:
Humans build software with other humans.
Someone discovers a project.
They read the documentation.
They find an issue.
Maybe they ask a question.
Maybe their first contribution gets rejected.
Someone explains why.
They try again.
Eventually, they understand more than the code.
They understand the project.
They understand why decisions were made.
They learn who the maintainers are.
They learn how the community communicates.
They learn the culture.
Then something interesting happens.
The person who once needed help starts helping somebody else.
Some become maintainers.
Some start their own projects.
Some become community leaders.
That cycle has produced an enormous amount of the technology the world depends on.
We normally describe open source using licences, forks, repositories, pull requests, and source availability.
But I don't think those things completely explain why open source became so powerful.
A lot of the real infrastructure of open source was human infrastructure.
The agent can solve the issue
Imagine an open source repository today.
There is an issue sitting there.
Traditionally, a contributor might discover it through GitHub.
They read the discussion.
They inspect the codebase.
They try to reproduce the problem.
They ask questions.
They misunderstand something.
Someone corrects them.
Eventually, they submit a pull request.
Maybe it gets rejected.
Maybe they learn why.
Now imagine the same issue with an agent.
I can tell an agent:
Find the cause of this issue.
Understand the repository.
Implement the fix.
Write the tests.
Update the documentation.
Prepare the pull request.
A maintainer can do exactly the same thing.
From a productivity point of view, this is incredible.
But from a community point of view, something else happened.
The issue was solved.
But nobody went through the journey.
Nobody discovered the project because of it.
Nobody had the conversation.
Nobody learned why the architecture looks the way it does.
Nobody developed a relationship with the maintainer.
Nobody became a little more capable because of that contribution.
The software improved.
But did the community?
The output was software. The other output was people.
A pull request produces code.
But historically, the process of producing that pull request also produced something else:
people who understood the software.
Issues weren't only task trackers.
Code reviews weren't only quality control.
Contributor guides weren't only instructions.
Hackathons weren't only about shipping features.
These mechanisms created routes into open source.
They taught people how to collaborate in public.
They exposed developers to unfamiliar codebases.
They created mentors, maintainers, community leaders, and sometimes founders.
The output was software.
The other output was people.
AI changes the economics of the first output dramatically.
What I am more interested in is what happens to the second.
Contribution and participation are separating
For most of open source history, contributing and participating were closely connected.
AI begins to separate those things.
An agent can contribute without becoming a participant.
It can fix an issue without belonging to the project.
It can create a technically excellent pull request without having any relationship with what happens to the project next year.
Maybe the next open source challenge isn't simply increasing contribution.
We have spent years optimizing for that.
Good first issues.
Contributor guides.
Hackathons.
Developer portals.
Automation.
Now we may be approaching a world where generating contributions becomes cheap.
The scarce thing may become something else.
Intentional participation.
Maybe the thing we were protecting was agency
Perhaps open source was never ultimately about simply seeing source code.
Source availability was the mechanism.
The deeper idea may have been agency.
The ability to understand the technology you depend on.
The ability to change it.
The ability to challenge decisions around it.
The ability to participate in its direction.
And the ability for communities, rather than only corporations, to accumulate technical knowledge.
So what happens if that collective knowledge base continues growing, but fewer humans actually understand how it is being produced?
The repository can remain open.
The licence can remain open.
The model can be open.
The agent can even be open.
But if humans increasingly become spectators to the production of the technology, is the ecosystem still open in the same meaningful sense?
I don't know.
But I think we need to ask.
I don't want less AI in open source
This isn't an argument for keeping AI agents out of open source.
Maintainers are overwhelmed.
Important projects are underfunded.
Security vulnerabilities sit unresolved.
Dependencies need constant maintenance.
Documentation becomes outdated.
Issues pile up.
If agents can remove some of that burden, we should use them.
The point is not whether we automate.
The point is what we accidentally automate away while doing it.
Reviewing someone's imperfect pull request takes longer than generating the correct implementation yourself.
But one produces a fix.
The other might produce a maintainer.
A contributor may take three days to understand an issue an agent solves in three minutes.
But the contributor may still be part of the community three years later.
Efficiency measures the patch.
Community measures what happens after the patch.
We need both.
What is the next generation of open source?
I don't have a new definition.
I think pretending that I do would defeat the point of writing this.
But I think we need to start asking different questions.
What does authorship mean when someone directs an agent that performs most of the implementation?
Who is responsible for an agent's contribution?
Should agent-generated contributions be disclosed?
How do new developers learn when many of the tasks they historically learned from can be completed automatically?
Do we need contribution pathways designed around humans working with AI?
And perhaps the biggest question:
How do we make sure open source continues producing people, not only software?
Does AI change everything?
In Geneva in 2023, that was a question.
At the time, we were trying to understand what was coming.
Now some of it is here.
I started with Copilot helping me write code.
Today, I can delegate increasingly large parts of software development to agents.
When I received the invitation to return to the Open Source Congress in 2026, even though I missed the gathering, it brought me back to the question we were asking three years earlier.
Does AI change everything?
Maybe not everything.
But it changes enough that we need to revisit some of the assumptions open source has carried for decades.
For years, one of the most powerful promises of open source wasn't simply:
You can use this software.
It was:
You can be part of building it.
As the art of building software changes, we need to decide what being part of building it means.
Maybe that is one of the most important open source conversations of the AI era.
And maybe the next generation of open source begins by having it.
