The next article initially appeared on Medium and is being republished right here with the creator’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 turned 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 sooner. It’s a special sort of velocity. AI is beginning to write, refactor, and remix code and open supply tasks 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 tip 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 developed. The story of open supply isn’t a straight line—it’s a sequence of turning factors. Every decade modified not simply the know-how but additionally the tradition round it: from insurrection within the Nineteen 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.
Nineteen 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 a perfect; it was how the online received constructed. Most websites ran Apache on the frontend however relied on business engines equivalent 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 programs—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 means. Anybody who realized command-line syntax on AIX within the early ’90s nonetheless journeys over it on macOS at present.
That shift—Linux and FreeBSD assembly the online—set the muse 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 essentially the most tactical win from the Nineteen Nineties was Linux. Though Linux didn’t turn into 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. Corporations that when offered closed programs 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 into a aggressive weapon, and being a committer had turn into 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” may fund a startup or land you a job.
As open supply gained momentum, visibility turned its personal type of energy. Being a committer was social capital, and fame inside the group created hierarchy. The motion that had began as a insurrection in opposition to proprietary management started to construct its personal “excessive locations.” Foundations turned phases; conferences turned politics. The centralized nature of CVS and Subversion bolstered this hierarchy—management over a single grasp repository meant management over the undertaking 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 tip of the last decade, open supply had recreated the very constructions 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 might reshape all of it: Git. It was controversial, messy, and deeply decentralized—the proper device on the proper time.
2010s: The Nice Decentralization
The 2010s decentralized all the things. Git unseated Subversion and CVS, making forking regular. GitHub turned model management right into a social community, and immediately open supply wasn’t a handful of central tasks—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 determine whether or not to merge again. That one concept modified the psychology of collaboration. Experimentation turned regular, not subversive.
The impact was explosive. SourceForge, dwelling to the CVS/SVN period, hosted about 240,000 tasks by 2010. Ten years later, GitHub counted roughly 190 million repositories. Even when half have been toy tasks, that’s a two-to-three-order-of-magnitude soar in undertaking 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 tasks” turned viable—half-finished frameworks, prototypes, and private experiments dwelling aspect by aspect with production-grade code. By mid-decade, open supply had entered its Cambrian part: Whereas the 2000s gave us 5 or 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 varieties one of many principal 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 record, earned belief, and possibly turned a committer. That was sluggish, political, and infrequently productive. However for you or the businesses you’re employed for to have the ability to affect a undertaking and commit code, we’re speaking months or years of funding.
Immediately, if a undertaking 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.
The truth is, you may not 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 might need forked a library, patched it on your particular use case, and printed it to your personal GitHub npm repository when 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 Achieved?
No. However it’s already altering. The massive tasks will proceed—React, Subsequent.js, and DuckDB will continue to grow as a result of AI fashions already want 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 tasks 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 an alternative of half a dozen steady frameworks per class, we’ll see a whole lot of small, AI-tuned frameworks and forks, every fixing one developer’s drawback completely after which fading away. The social glue that when sure open supply—mentorship, debate, shared upkeep—will get thinner. Collaboration offers option to radical personalization. And I don’t know if that’s such a foul 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 stories 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 tip 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 in all probability don’t—and possibly don’t have to. The agent already forked it and moved on.
Perhaps that’s the brand new freedom: to fork, to neglect, and to let the machines keep in mind for us.