The 10-minute code dive: AI finally delivers open source's original promise

A developer asks an AI coding assistant to clone an unfamiliar GitHub repository, get it to build, and explain how one specific function works. Ten minutes later, the code is compiled and the answer is on the screen. That used to be a multi-hour project reserved for specialists — and the shift is what the open-source license was nominally promising all along.

The open-source license has always been a two-part deal: you can read the code, and you can modify it. The "can" was real. The "would" was rarer. Checking out a stranger's project, getting the dependencies to resolve, and working out what a particular function was supposed to do was a barrier most people never cleared. AI coding agents — software like OpenAI's Codex, the open-source Shelley from exe.dev, and Anthropic's Claude Code — are the first tools that have plausibly flattened that barrier, and the people using them are starting to notice.

Simon Willison, the developer behind datasette and one of the more observant commentators on this beat, described the new pattern on 3 August: "I now prompt Claude chat several times a day with things like 'Clone x/y from GitHub and tell me how Z works.'" He frames the clone-and-build step as a "zero time investment challenge" rather than a weekend project. The implication is not that AI is writing his code; it is that AI is removing the gatekeeping on reading someone else's.

The same day, an operator at exe.dev made the more pointed argument: the original open-source promise — "freedom to modify" — was always more aspirational than practical, and that is changing. The post draws a sharp line between two kinds of coding agents. Open-source agents like Codex and Shelley's own Shelley can be extended by loading a discoverable "skill," a plain-text instruction that changes the agent's behavior, so personalization becomes a prompt, not a fork. Closed-source agents like Claude Code cannot be modified this way because their internals are not inspectable. The freedom to modify, in other words, now depends on what the agent itself is made of.

The mechanism works on two fronts at once. Starting to personalize a project is much cheaper when an agent can absorb the build steps for you. Staying personalized is also much cheaper when the same agent can run a nightly rebase against upstream, reapplying your local changes on top of whatever the maintainers shipped that day. Willison links to a personal project, meat.dev, that takes a code diff and uses a language model to strip out rote-correctness lines — imports, nil-checks, error handling — so the human reviewer can focus on architecture and surprising uses. The point is not that the diff is shorter. The point is that the human time is now spent on the parts of the code that actually require judgment.

This is, deliberately, a narrow claim. Willison is one developer. The exe.dev post is one operator arguing from first principles. Both agree the friction has collapsed, and both agree the habit is not yet universal. The two-front mechanism — cheaper to start, cheaper to keep going — only works if the agent can actually be steered, which means the tools that benefit most are the ones whose behavior is open to inspection. The closed-source agents handle the "read unfamiliar code" half of the bargain but not the "modify it on your own terms" half.

The wider question is what happens to the line between "user" and "contributor" of open-source software. If a ten-minute clone-and-explain loop becomes ordinary, the old assumption that contributing means spending a weekend getting someone else's build chain to cooperate starts to break. But "starts to break" is the right verb. The pattern is visible, the workflow is real, and the people describing it are not making it up. Whether the rest of the developer population picks it up — and whether it generalizes past small, well-tested repositories — are the next questions to answer.

The test, for now, is falsifiable. Ask a coding agent to clone a non-trivial open-source project, get it to build, and explain one specific subsystem in plain language. If ten minutes is the right order of magnitude, the story holds. If it is forty minutes, or two hours, the friction has only been dented, not collapsed.