Linus Torvalds has said the writing took about 10 days before he could use Git for Linux kernel work—but he had spent roughly four months thinking through the problem and design first. That makes his story a useful comparison point for asking a local LLM to build a Git-like tool with one prompt, not proof that a prompt can recreate Git.
Did Linus Torvalds really write Git in 10 days?
That is how Torvalds characterized the implementation milestone: about 10 days of writing until he started using Git for kernel work. In the same 2025 interview, he said he had already spent about four months thinking about the problem and what a replacement should do. The 10-day figure is not the time from first idea to finished version-control system.
As an Amazon Associate I earn from qualifying purchases.
Git’s first commit was made on April 7, 2005. GitHub’s anniversary interview says that first version was already self-hosted enough to make its own initial commit. A 2015 Linux.com interview describes Git as becoming self-hosting after about a day, while the roughly 10-day point was when Torvalds began using it for kernel work. These are different milestones, not competing estimates of a single completion date.
Quick wins for a faster PC:
Scan for outdated or missing drivers - takes under a minuteDriver Scan →Repair Windows errors before they cause bigger problemsFix Now →Torvalds’s account is a retrospective, not a measured time log. He also described his own work across Git’s subsequent 20 years as about four months, crediting Junio Hamano and other contributors with much of the rest. Git’s history is therefore both an early implementation story and a long-running community project.
#1 Best Overall
Why did Git need to exist?
The Linux kernel community needed a distributed and efficient way to manage source code. BitKeeper had worked well for Torvalds, but its commercial status became contentious in the community. Conflict involving reverse engineering and licensing led him to seek a replacement. He considered the available alternatives inadequate for his needs and wanted something that did not simply reproduce BitKeeper’s design.
Performance and reliability mattered because Git was intended for a large, active kernel project. In a 2015 interview, Torvalds summarized the central challenge as data organization: “The trick wasn’t really so much the coding but coming up with how it organizes the data.” In 2025, he again emphasized that a few fundamental low-level ideas underpin the system, while much of the complexity accumulates in the details and user interface.
Rank #2
That context changes how to read the 10-day figure. It describes a focused period of implementation after substantial design thinking, aimed at a demanding real workflow. It does not mean that Git’s architecture, features, ecosystem, or maintainability emerged fully formed in ten days.
Recommended Free Tools
What does “something similar” mean for a one-prompt LLM build?
A one-prompt experiment can produce an interesting prototype, but the phrase “Git-like” needs a testable definition. A tool that creates a repository and records a commit is not automatically comparable to Git as used for kernel development. To make the comparison meaningful, report what the generated program actually does and where it stops.
- Time: Record the time from prompt to first output, any time spent revising the prompt or fixing generated code, and any design work done beforehand. These are distinct from Torvalds’s writing period and prior design work.
- Scope: List supported operations—such as initializing a repository, staging changes, committing, inspecting history, branching, merging, or working with remotes—and identify unsupported behavior.
- Correctness and data integrity: Show the tests used, including failure cases such as interrupted writes, conflicting changes, malformed data, or attempts to recover from a damaged repository. State whether data loss or corruption was observed; do not imply safety from a few successful commands.
- Performance and scale: Give the repository size and workload used for any timing or scale claim. A toy example cannot establish performance for a Linux-kernel-sized workflow.
- Usability: Explain whether someone other than the prompt author can install, understand, and use the result from its documentation, without unstated assumptions.
- Maintenance: Describe whether the code has a coherent design and tests that support later changes, rather than only demonstrating a successful first run.
There is no common benchmark in the cited accounts that directly compares Torvalds’s work with a prompt-generated prototype. Any result from the LLM experiment should therefore be presented as the author’s own observation, with its prompt, environment, test setup, and limitations—not as evidence that an AI can reproduce Git in equivalent time.
How should the local LLM experiment be judged?
The experiment is compelling as a question: can a single prompt produce a useful version-control prototype? The historical comparison sharpens that question, but does not answer it. The available accounts establish Torvalds’s design period and early milestones; they do not independently verify which model or prompt was used, what code it produced, or how that code performed.
A strong account of the experiment should include the prompt and the generated project’s observable behavior. For each claimed feature, show a reproducible example or test. Separate an initial generation from later edits, and say plainly when a feature is absent or untested. That lets readers distinguish a quick demonstration from a dependable tool without confusing the two with Git’s later, community-built capabilities.
Free tools Windows power users keep installed
One-click scans. No signup required.
What the story says about AI coding today
AI coding agents make Git practices more—not less—important. GitHub’s 2025 discussion of Git’s future points to practical workflow questions around meaningful commit messages and context-aware amending, squashing, and rebasing. An agent that can emit code is only part of a software workflow; changes still need to be understandable, reviewable, and safely managed.
That is the useful connection between Git’s origin and a one-prompt build. The striking part of Git’s early history is not just the short writing period. It is that implementation followed months of thinking about a real problem, and the project then grew through years of work by many contributors. A local LLM prototype should be assessed on its demonstrated scope and reliability, rather than on the speed or drama of its first output.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
