The next article initially appeared on Medium and is being republished right here with the writer’s permission.
Open supply has been evolving for half a century, however the final twenty years have set the stage for what comes subsequent. The 2000s have been the “star stage”—when open supply grew to become mainstream, industrial, and visual. The 2010s decentralized it, breaking the hierarchy and making forking regular. Now, within the 2020s, it’s remodeling once more as generative AI enters the scene—as a participant.
This decade isn’t simply sooner. It’s a unique sort of velocity. AI is beginning to write, refactor, and remix code and open supply initiatives at a scale no human maintainer can match. GitHub isn’t simply increasing; it’s mutating, full of AI-generated derivatives of human work, on monitor to handle near 1B repositories by the top of the last decade.
If we need to perceive what’s occurring to open supply now, it helps to look again at the way it advanced. The story of open supply isn’t a straight line—it’s a collection of turning factors. Every decade modified not simply the expertise but additionally the tradition round it: from insurrection within the Nineties to recognition within the 2000s to decentralization within the 2010s. These shifts constructed the inspiration for what’s coming subsequent—an period the place code isn’t simply written by builders however by the brokers they’re managing.
Nineties: Setting the Stage
The late ’80s and early ’90s have been outlined by proprietary stacks—Home windows, AIX, Solaris. By the mid-’90s, builders started to insurgent. Open supply wasn’t simply an excellent; it was how the online bought constructed. Most websites ran Apache on the frontend however relied on industrial engines similar to Dynamo and Oracle on the backend. The primary internet was open on the edges and closed on the core.
In universities and analysis labs, the identical sample emerged. GNU instruments like Emacs, GCC, and gdb have been in every single place, however they ran on proprietary techniques—SGI, Solaris, NeXT, AIX. Open supply had taken root, even when the platforms weren’t open. Mike Loukides and Andy Oram’s Programming with GNU Software program (1996) captured that world completely: a maze of UNIX variants the place each system broke your scripts in a brand new manner. Anybody who discovered command-line syntax on AIX within the early ’90s nonetheless journeys over it on macOS right this moment.
That shift—Linux and FreeBSD assembly the online—set the inspiration for the subsequent decade of open infrastructure. Clearly, Tim Berners-Lee’s work at CERN was the pivotal occasion that outlined the subsequent century, however I believe probably the most tactical win from the Nineties was Linux. Despite the fact that Linux didn’t turn out to be viable for large-scale use till 2.4 within the 2000s, it set the stage.
2000s: The Open Supply Decade
The 2000s have been when open supply went mainstream. Firms that when bought closed techniques began funding the foundations that challenged them—IBM, Solar, HP, Oracle, and even Microsoft. It wasn’t altruism; it was technique. Open supply had turn out to be a aggressive weapon, and being a committer had turn out to be a type of social capital. The communities round Apache, Eclipse, and Mozilla weren’t simply writing code; they constructed a form of popularity sport. “I’m a committer” may fund a startup or land you a job.
As open supply gained momentum, visibility grew to become its personal type of energy. Being a committer was social capital, and fame inside the neighborhood created hierarchy. The motion that had began as a insurrection in opposition to proprietary management started to construct its personal “excessive locations.” Foundations grew to become phases; conferences grew to become politics. The centralized nature of CVS and Subversion strengthened this hierarchy—management over a single grasp repository meant management over the venture itself. Forking wasn’t seen as collaboration; it was defiance. And so, even in a motion dedicated to openness, authority started to pay attention.
By the top of the last decade, open supply had recreated the very buildings it as soon as tried to dismantle and there have been energy struggles round forking and management—till Git arrived and quietly made forking not simply regular however inspired.
In 2006, Linus Torvalds quietly dropped one thing that may reshape all of it: Git. It was controversial, messy, and deeply decentralized—the suitable device on the proper time.
2010s: The Nice Decentralization
The 2010s decentralized every part. Git unseated Subversion and CVS, making forking regular. GitHub turned model management right into a social community, and all of a sudden open supply wasn’t a handful of central initiatives—it was 1000’s of competing experiments. Git made a fork low cost and native: Anybody may department off immediately, hack in isolation, and later resolve whether or not to merge again. That one thought modified the psychology of collaboration. Experimentation grew to become regular, not subversive.
The impact was explosive. SourceForge, residence to the CVS/SVN period, hosted about 240,000 initiatives by 2010. Ten years later, GitHub counted roughly 190 million repositories. Even when half have been toy initiatives, that’s a two-to-three-order-of-magnitude leap in venture creation velocity—roughly one new repository each few seconds by the late 2010s. Git didn’t simply velocity up commits; it modified how open supply labored.
However the identical friction that disappeared additionally eliminated filters. As a result of Git made experimentation easy, “throwaway initiatives” grew to become viable—half-finished frameworks, prototypes, and private experiments residing aspect by aspect with production-grade code. By mid-decade, open supply had entered its Cambrian part: Whereas the 2000s gave us 5 – 6 credible frontend frameworks, the 2010s produced 50 or 60. Git didn’t simply decentralize code—it decentralized consideration.
2020s: What Will We Name This Decade?
Now that we’re midway by the 2020s, one thing new is occurring. Generative AI has slipped quietly into the workflow, reshaping open supply as soon as once more—not by killing it however by making forking even simpler. It additionally varieties one of many fundamental coaching inputs for the output it generates.
Return twenty years to the 2000s, if a library didn’t do what you wanted, you joined the mailing listing, earned belief, and perhaps grew to become a committer. That was gradual, political, and infrequently productive. However for you or the businesses you’re employed for to have the ability to affect a venture and commit code, we’re speaking months or years of funding.
Right this moment, if a venture is 90 p.c proper, you fork it, describe the repair to an AI, and you progress on 5 minutes later. No evaluate queues. No debates about brace types. The pull-request tradition that when outlined open supply begins to really feel non-obligatory as a result of you aren’t investing any time in it to start with.
In truth, you may not even bear in mind that you simply forked and patched one thing. One of many 10 brokers you launched in parallel to reimplement an API might need forked a library, patched it to your particular use case, and revealed it to your non-public GitHub npm repository whilst you have been at lunch. And also you may not even be being attentive to these particulars.
Pattern prediction: We’re going to have a nickname for builders who use GenAI and are unable to learn the code it generated very quickly as a result of that’s occurring.
Is Open Supply Finished?
No. But it surely’s already altering. The large initiatives will proceed—React, Subsequent.js, and DuckDB will continue to grow as a result of AI fashions already favor them. And I do suppose there are nonetheless communities or builders who need to collaborate with different people.
However there’s a surge of AI-generated open supply contributions and initiatives that may begin to have an effect on the ecosystem. Smaller, extra centered libraries will begin to see extra forks. That’s my prediction, and it would get to the purpose the place it doesn’t make a lot sense anymore to trace them.
As a substitute of half a dozen steady frameworks per class, we’ll see lots of of small, AI-tuned frameworks and forks, every fixing one developer’s downside completely after which fading away. The social glue that when certain open supply—mentorship, debate, shared upkeep—will get thinner. Collaboration offers approach to radical personalization. And I don’t know if that’s such a nasty factor.
The Fork-It-and-Overlook Decade
That is shaping as much as be the “fork-it-and-forget” decade. Builders—and the brokers they run—are shifting at a brand new sort of velocity: forking, patching, and shifting on. GitHub studies greater than 420 million repositories as of early 2023, and it’s on tempo to hit a billion by 2030.
We tore down the “excessive locations” that outlined the 2000s and changed them with the frictionless innovation of the 2010s. Now the query is whether or not we’ll even acknowledge open supply by the top of this decade. I nonetheless take note of the libraries I’m pulling in, however most builders utilizing instruments like Cursor to put in writing complicated code in all probability don’t—and perhaps don’t must. The agent already forked it and moved on.
Possibly that’s the brand new freedom: to fork, to overlook, and to let the machines bear in mind for us.