LLMs are finally making the open source dream of inspecting and modifying software a reality for everyone

Why it matters: A decades-old dream suddenly feels within reach.

The open source movement was born with a compelling promise: users can not only use software, they can freely inspect its inner workings and modify it to suit their needs. It sounds wonderful, but reality has fallen short. Even skilled programmers rarely exercise this right. Reading unfamiliar code, setting up a build environment, and understanding the architecture demands chunks of time and motivation that most people simply don't have. Over the years, the “freedom to inspect and modify” remained largely a legal concept; in practice, we all used open source tools as black boxes.

Large language models are now fundamentally changing that equation. In a recent commentary, Simon Willison shared his experience: several times a day he uses tools like Claude and simply asks, “Clone this repo from GitHub and tell me how feature X works.” Steps that used to stop him in his tracks—getting code to compile before you can even start hacking—have become zero-friction tasks. He tells Codex or Claude Code to checkout and build something, then checks back ten minutes later to see the results. He hasn't yet formed a habit of modifying the software he uses, but a clear path has emerged that simply didn't exist a year ago.

How LLMs tear down the “time wall” and turn it into a door.

Traditionally, modifying open source software involved several daunting barriers:

1. The understanding barrier: you need to read a lot of code just to know where to change things.
2. The environment barrier: setting up the build system and dependencies often kills motivation.
3. The risk barrier: your change might introduce bugs, and debugging is expensive.

LLMs knock down all these walls simultaneously. They can read code and produce human-readable explanations, letting you grasp an unfamiliar module within minutes. They can automate tedious build steps and even attempt compilation, reporting back on the results. More importantly, if you only need a small customization, an LLM can generate a patch and even suggest test cases. What once might have required a weekend of deep diving can now be accomplished in a coffee break.

The significance isn't that programmers are becoming lazy, but that the “right to modify” is finally becoming the “ability to modify.” Think of it like having a mechanic friend on call: you don't need to become a mechanic yourself to make useful adjustments to your car.

A bigger trend: the open source gravity is shifting from “release” to “participate.”

For two decades, the open source community has focused on releasing code: making it public for review, forking, and pull requests. But the barrier to deep participation has remained high. What LLMs are lowering is not code quality, but cognitive load. As the cost of exploring any project approaches zero, we may see a new mode of open source participation: a flood of lightweight, personal modifications. These changes may never get pushed upstream; instead, they'll live on individuals' local branches, satisfying unique, niche needs.

This connects to a larger trend: AI is making software more liquid. Previously, software was a fixed product; users were stuck with preset features. Now, software is becoming a material you can reshape on the fly. Open source was always meant to be the pioneer of this trend, and LLMs are the magic wand that makes reshaping easy. Just as Andrej Karpathy said “Markdown is becoming the programming language of AI,” we might say: “Natural language is becoming the new API for open source software.”

What you can do today: an LLM-assisted open source workflow.

Even if you're just a regular developer annoyed by some tool's behavior, you can try a flow like this:

1. Clone the repo of the tool you're using (ask an LLM to do it for you).
2. Have a conversation: “I want to change behavior X, which file handles it?” “What's the structure of this code?” “If I change this to Y, what would be affected?”
3. Ask the LLM to generate a patch and attempt a build, then see the result.

You don't need to be an expert on that project or understand every line. You just need a clear description of what you want and the discipline to verify the output. This is fundamentally different from using a search engine, which can only give you documentation and Stack Overflow threads. An LLM can give you a concrete modification tailored to your exact environment.

A counterintuitive angle: it's not about AI replacing contributors, but empowering edge cases.

Some might fear that open source maintainers will be flooded with AI-generated PRs. But Simon's perspective doesn't point in that direction. The scenario he paints is mostly personal, on-the-fly tweaks—not mass submissions to upstream repos. This highlights a hidden value of open source: it's not just a foundation for global collaboration, but also a tool for personal digital sovereignty. For the first time, LLMs make “I can modify this software to behave exactly how I want” a viable option for most people, not just a privileged few. You can think of it as digital “mending and altering,” giving each of us a genuine sense of control over the tools we use.

This trend is just budding, but its direction is clear. When the cost of modifying software drops to the level of sending an email, the original flame of freedom and autonomy that ignited the open source movement might finally reach everyone's desktop.