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 20 years have set the stage for what comes subsequent. The 2000s had been the “star stage”—when open supply grew to become mainstream, business, 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 quicker. It’s a unique form 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, stuffed with AI-generated derivatives of human work, on observe to handle near 1B repositories by the top of the last decade.
If we wish to perceive what’s occurring to open supply now, it helps to look again at the way it developed. The story of open supply isn’t a straight line—it’s a collection of turning factors. Every decade modified not simply the know-how but in addition the tradition round it: from rise up within the Nineties to recognition within the 2000s to decentralization within the 2010s. These shifts constructed the muse 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 had been outlined by proprietary stacks—Home windows, AIX, Solaris. By the mid-’90s, builders started to insurgent. Open supply wasn’t simply a great; it was how the online acquired constructed. Most websites ran Apache on the frontend however relied on business engines equivalent to Dynamo and Oracle on the backend. The primary net 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 had been all over the place, however they ran on proprietary methods—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 realized command-line syntax on AIX within the early ’90s nonetheless journeys over it on macOS immediately.
That shift—Linux and FreeBSD assembly the online—set the muse for the following decade of open infrastructure. Clearly, Tim Berners-Lee’s work at CERN was the pivotal occasion that outlined the following century, however I feel essentially the most tactical win from the Nineties was Linux. Despite the fact that Linux didn’t grow to be viable for large-scale use till 2.4 within the 2000s, it set the stage.
2000s: The Open Supply Decade
The 2000s had been when open supply went mainstream. Firms that when offered closed methods began funding the foundations that challenged them—IBM, Solar, HP, Oracle, and even Microsoft. It wasn’t altruism; it was technique. Open supply had grow to be a aggressive weapon, and being a committer had grow to be a type of social capital. The communities round Apache, Eclipse, and Mozilla weren’t simply writing code; they constructed a type of repute recreation. “I’m a committer” might 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 throughout the neighborhood created hierarchy. The motion that had began as a rise up in opposition to proprietary management started to construct its personal “excessive locations.” Foundations grew to become levels; conferences grew to become politics. The centralized nature of CVS and Subversion bolstered this hierarchy—management over a single grasp repository meant management over the challenge 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 fitting device on the proper time.
2010s: The Nice Decentralization
The 2010s decentralized every thing. 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 might 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, dwelling to the CVS/SVN period, hosted about 240,000 initiatives by 2010. Ten years later, GitHub counted roughly 190 million repositories. Even when half had been toy initiatives, that’s a two-to-three-order-of-magnitude soar in challenge 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 dwelling facet by facet 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 way of the 2020s, one thing new is going on. 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 kinds one of many principal coaching inputs for the output it generates.
Return 20 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 sluggish, political, and sometimes productive. However for you or the businesses you’re employed for to have the ability to affect a challenge and commit code, we’re speaking months or years of funding.
Immediately, if a challenge is 90 % proper, you fork it, describe the repair to an AI, and you progress on 5 minutes later. No overview 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.
The truth is, you won’t even bear in mind that you just forked and patched one thing. One of many 10 brokers you launched in parallel to reimplement an API may need forked a library, patched it in your particular use case, and printed it to your non-public GitHub npm repository when you had been at lunch. And also you won’t 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. However it’s already altering. The massive initiatives will proceed—React, Subsequent.js, and DuckDB will continue to grow as a result of AI fashions already choose them. And I do assume there are nonetheless communities or builders who wish 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 targeted 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 an alternative of half a dozen secure frameworks per class, we’ll see a whole lot of small, AI-tuned frameworks and forks, every fixing one developer’s downside completely after which fading away. The social glue that when sure 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 foul factor.
The Fork-It-and-Neglect Decade
That is shaping as much as be the “fork-it-and-forget” decade. Builders—and the brokers they run—are transferring at a brand new form of velocity: forking, patching, and transferring on. GitHub experiences 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 write down advanced code most likely don’t—and perhaps don’t must. The agent already forked it and moved on.
Perhaps that’s the brand new freedom: to fork, to overlook, and to let the machines bear in mind for us.