Linus Torvalds Workflow: Why The Linux Creator Now Only Uses Git

The technology industry is currently entranced by the allure of automated code generation, massive AI orchestration, and complex continuous integration pipelines. However, at the absolute core of the global digital infrastructure lies a starkly different paradigm. The Linus Torvalds workflow—the operational philosophy that governs the world’s most critical open-source project—eschews nearly every modern development convenience. Speaking at the Open Source Summit in Mumbai in July 2026, the creator of the Linux operating system offered a profound revelation that challenges the very foundation of modern software engineering: “I’m not a programmer anymore.” Instead, Torvalds has transitioned into an elite development lead, relying exclusively on two archaic yet wildly battle-tested tools: Git and plain text email. As the industry races toward AI-generated pull requests and centralized cloud repositories, Torvalds’s steadfast commitment to asynchronous, human-centric management offers a masterclass in scale, security, and architectural purity.

The Architectural Reality of the Linus Torvalds Workflow

To understand the sheer magnitude of the Linux kernel, one must recognize that it is not merely a codebase; it is the fundamental engine that powers everything from hyper-scale Enterprise IT cloud deployments to embedded IoT devices. Operating this massive engine requires a governance model built on extreme filtration. Torvalds has famously stated that his job, ultimately, is “to say no” to filter contributions and maintain impeccably high standards. The architectural reality of the Linux kernel is that it operates as a rigid hierarchy of trust, where subsystem maintainers act as the first line of defense against fragile, unoptimized code.

Unlike modern development teams that rely on centralized platforms like GitHub, the Linux developer community utilizes an entirely decentralized, email-driven review process. Contributors submit patches using exactly git format-patch and git send-email. This text-based, asynchronous protocol is vastly superior for scaling massive codebases because it strips away the bloat of web-based pull request interfaces. Torvalds prefers this text-based, highly asynchronous, and scalable review process, utterly rejecting modern instant messaging tools like Slack or Discord for code review. Torvalds reviews these incoming streams of plain text, occasionally drafting pseudocode directly within his email client to offer structural feedback. This is a system where the quality of the commit message is valued almost as highly as the C code itself. A poorly explained pull request will be summarily rejected, forcing developers to articulate the intent and overarching consequence of their changes.

During a standard two-week merge window, Torvalds executes roughly 200 merges. This staggering volume is manageable only because he has shifted his focus from low-level implementation to high-level architectural intent. He explicitly avoids automated CI/CD pipelines and the myriad of testing suites that other maintainers use, acknowledging that he is “unusual” in this regard. His professional activity is entirely restricted to Git—which he created in ten days to handle this exact workload—and email, with Google utilized solely as a quick reference tool. This methodology ensures that every line of code merging into the mainline kernel has passed through a gauntlet of human scrutiny, preserving the structural integrity of a system that absolutely cannot afford to fail.

Market Impact & Deployment Scale

From a corporate perspective, the implications of Torvalds’s leadership style translate directly into Total Cost of Ownership (TCO) and risk mitigation for Fortune 500 companies. The Linux kernel’s steady, incremental release schedule—typically every nine to ten weeks—avoids the disruptive nature of “splashy” feature drops. This predictability allows organizations to forecast server maintenance, kernel upgrades, and security patching with absolute precision, saving millions in potential downtime and lost engineering hours.

A critical aspect of this deployment strategy is the aggressive pruning of obsolete technology. Torvalds is entirely unsentimental about legacy code. For instance, in the upcoming Linux 7.2 release, support for x86 machines lacking hardware floating-point units—specifically the Intel 486 SX, which debuted over three decades ago—is being terminated. Similarly, outdated networking standards such as ISDN and ATM are being permanently excised from the codebase. For modern Hardware & Silicon deployments, this relentless purging is essential. Carrying the technical debt of “museum” technology introduces unnecessary attack vectors and slows down the compilation and validation of new features. If enterprise users are determined to run Linux on a 386 processor, they are relegated to older, unmaintained kernel versions, effectively pushing the industry forward by force. Furthermore, on the highly-troublesome Microsoft NTFS subsystem, Torvalds noted that two different groups are maintaining two separate versions of NTFS; in a brilliantly pragmatic move, he is letting them “fight it out” to see which implementation reigns supreme.

The intersection of legacy languages and modern safety requirements also plays a pivotal role in market deployment. While Rust has been hailed as a panacea for memory safety vulnerabilities, Torvalds remains pragmatically cautious. He acknowledges that Rust resolves specific classes of memory errors, but firmly warns that it does not fix fundamental logic errors or poor programming practices. In mixed codebases, the safety guarantees of Rust evaporate the moment it interacts with C code. Consequently, Torvalds champions the continued dominance of C, relying heavily on advanced verification tools like Sashiko rather than blindly trusting a new language to prevent architectural security flaws.

Navigating the AI Paradigm Shift and Hallucinations

As the industry pivots toward autonomous coding agents, the Linux kernel has become a proving ground for the limitations of Large Language Models (LLMs). Within the realm of AI & Machine Learning, there is a pervasive myth that AI will seamlessly write, test, and deploy secure infrastructure code. Torvalds’s recent experiences dismantle this narrative with sobering reality. He recently walked back previous, unscientific claims that LLMs could deliver a “10x” productivity boost, noting instead that the kernel community had been flooded with “junk” generated by AI up until early 2026.

The most insidious problem is the hallucinated bug report. LLMs frequently generate highly plausible, technically sophisticated bug reports that are entirely fabricated. For kernel maintainers, investigating these false positives represents a massive, unacceptable drain on human resources. Consequently, Torvalds has instituted a strict mandate: it is no longer sufficient to throw an AI-generated bug report over the fence. Contributors must supply a verifiable, human-vetted patch alongside the report, acting as a mandatory back-and-forth buffer.

Furthermore, when LLMs do manage to identify genuine vulnerabilities—some of which have lurked in the codebase for two decades and subsequently embarrassed maintainers in the technology press—the suggested fixes are often described as “mindless band-aids.” An AI might patch the immediate symptom of a memory leak, but it entirely misses the underlying architectural flaw, leaving the true bug waiting in the hallway to strike again in a different subsystem. For this reason, Torvalds uses LLMs merely as rapid prototyping tools for “toy projects”—and playfully adding Godzilla to his vacation photos in India—rather than trusting them with mission-critical kernel modifications.

The Consumer Translation

To the everyday user streaming a movie on an Android smartphone or loading a complex web application, the rigid, email-centric governance of the Linux kernel might seem entirely disconnected from daily life. However, this high-level technical shift has profound downstream effects on the worldwide public.

Consider a structural analogy: managing the Linux kernel is equivalent to acting as the chief architect of the global air traffic control system. The architect doesn’t personally fly the planes or design the engines (programming); instead, they design the strict protocols that ensure thousands of massive jets (code branches) from different airlines (corporations) can safely navigate the same airspace without colliding. If a new airline proposes a route that jeopardizes the system, the architect simply says “no.”

By ruthlessly excising obsolete hardware and buggy legacy file systems, the kernel becomes leaner, faster, and significantly more secure. This means the servers hosting bank transactions use less electricity, consumer smartphones experience fewer hard crashes, and internet routing hardware remains resilient against state-sponsored cyberattacks. The decision to reject automated pull requests in favor of harsh, text-based human scrutiny directly translates into a digital ecosystem that prioritizes absolute stability over reckless development speed.

Frequently Asked Questions

Q1: What tools does Linus Torvalds use for Linux kernel development?
A1: Linus Torvalds relies exclusively on Git and plain-text email for managing the Linux kernel. He explicitly avoids modern IDEs, automated CI/CD platforms, and web-based pull requests, favoring a text-based, asynchronous review process.

Q2: Does Linus Torvalds still write code for Linux?
A2: Torvalds rarely writes code anymore, characterizing himself as a development lead and manager. He occasionally writes pseudocode in his email client as suggestions, but leaves the actual implementation and testing to subsystem maintainers.

Q3: How is AI impacting Linux kernel development?
A3: AI and Large Language Models are helping find bugs, but Torvalds notes they often generate “junk” or shallow band-aid patches. He insists that any AI-generated bug report must be accompanied by a human-verified patch to avoid draining maintainer resources.

Q4: Is Linux dropping support for old hardware?
A4: Yes, the Linux kernel is actively purging support for obsolete hardware, such as machines without hardware floating-point units on x86 architecture (like the 486 SX). Torvalds stated that maintaining legacy museum technology has become an unsustainable burden.

Q5: Why does Torvalds prefer C over Rust?
A5: While acknowledging Rust’s benefits for memory safety, Torvalds still considers C a much simpler and more powerful tool. He warned that Rust cannot fix fundamental logic errors or bad programming, which continue to cause high-profile bugs.

TechNode HQ Verdict: Pros, Cons & Usability

• Pro (Engineering): The decentralized, email-driven workflow allows the Linux project to scale asymmetrically, maintaining extreme architectural oversight without centralized platform bottlenecks.
• Pro (Consumer): Ruthless code pruning and refusal of “band-aid” patches result in unparalleled operating system stability for end-user devices ranging from Android phones to smart appliances.
• Con: The intense, text-based communication style creates a massive cultural barrier to entry, threatening long-term developer succession planning as younger generations expect visual, web-based collaboration.
• Con: A steep over-reliance on a single development lead to parse roughly 200 merges in a two-week window creates a critical single-point-of-failure in global IT infrastructure.

Enterprise Usability: CTOs should take note of the Linux kernel’s zero-trust approach to AI code generation. Enterprises must implement human-in-the-loop verification processes before deploying LLM-generated patches to production environments, treating AI as an assistant rather than an autonomous engineer.

Everyday Usability: Consumers benefit silently from this invisible war on bad code. The refusal to support obsolete technology means modern devices run vastly optimized, secure software, justifying the push toward newer, capable hardware over attempting to salvage obsolete tech.