Linus Torvalds Was Right About Vibe Coding

February 15, 2026 • 11 min read

“Even Linus Torvalds Is Vibe Coding Now.”

That was the Slashdot headline in late January 2026, and it went exactly as viral as you’d expect. The creator of Linux and Git—a man who has spent three decades insisting that you read the code, understand the code, and take personal responsibility for the code—was caught using an AI tool to generate a Python project. The internet had a field day. The irony was too perfect. Even Linus caved.

Except he didn’t cave. He was making exactly the point he’d been making all along. And if you look past the headline and into what he actually did, the story isn’t about hypocrisy. It’s about judgment. It’s about knowing the difference between a script and a system—and treating them accordingly.

Torvalds was right about vibe coding. Not because vibe coding is bad, but because most people use it without the discipline it requires. And until you understand where that line is, you’re going to keep building things that work on Tuesday and collapse by Friday.

What Torvalds Actually Said

Before the Slashdot headline, before the Python project, there was a talk. In November 2025, Torvalds spoke at the Linux Foundation Open Source Summit in Seoul. And he didn’t mince words about AI-generated code.

“It’s fine for getting started. But it’s a horrible, horrible idea from a maintenance standpoint.”

— Linus Torvalds, Open Source Summit, Seoul, November 2025

That’s the full quote. Not “AI is bad.” Not “vibe coding is a toy.” Not “real programmers don’t use LLMs.” He said it’s fine for getting started. And he said it’s horrible for maintenance. Both of those things are true, and the tension between them is the entire point.

Torvalds has maintained the Linux kernel for over thirty years. He reviews patches from thousands of contributors. He has seen what happens when someone submits code they don’t fully understand—and he’s seen it at scale, across decades. When he says “maintenance standpoint,” he’s not speaking theoretically. He’s speaking from the lived experience of managing one of the largest, most critical software projects in human history.

So when the same man turns around two months later and uses Google’s Antigravity AI to generate a Python audio visualizer, the question isn’t “is he a hypocrite?” The question is “why did he think that was fine?”

The Python vs. C Distinction

Here’s what actually happened. Torvalds has a hobby project called AudioNoise—a personal audio visualization tool. In January 2026, he used Google’s Antigravity AI to vibe-code the Python components: the visualization layer, the UI scaffolding, the glue scripts that wire audio input to graphical output.

He hand-wrote all the C components himself.

That distinction is not accidental. It’s the entire philosophy in a single decision. The Python code is a display layer. If it breaks, you restart it. If it has a bug, you regenerate it. If it needs to change, you throw it away and describe the new version. The blast radius of a failure is small. The cost of replacement is low. The maintenance burden is something one person can carry without deep structural knowledge of every line.

The C code is different. The C code is the audio processing pipeline. It deals with memory management, buffer handling, timing, and system-level interfaces. A bug in that layer doesn’t produce a glitchy animation. It produces a segfault, a memory leak, or silent data corruption that shows up three months later under conditions you can’t reproduce. That code demands that the author understand what every line does and why.

Torvalds didn’t vibe-code the parts that matter for longevity. He vibe-coded the parts that are, by design, disposable.

The Maintenance Problem

The Seoul talk wasn’t really about AI. It was about a pattern Torvalds has been fighting for decades: people submitting code they don’t understand.

Before AI tools, the problem was copy-pasting from Stack Overflow. Before that, it was cargo-culting from textbooks. The tool changes; the failure mode is the same. Someone puts code into a project, the code works today, and nobody can explain why it works—which means nobody can fix it when it stops working.

Vibe coding accelerates this failure mode by an order of magnitude. Instead of copying one function from Stack Overflow, you generate an entire module from a prompt. Instead of not understanding ten lines, you don’t understand two hundred. And because the generated code works immediately—because LLMs are very good at producing code that passes the first test—there’s no friction to slow you down. No moment where you have to stop and think “wait, what does this actually do?”

Six months later, the person who generated the code has moved on to another project, another company, or another prompt. The person who inherits the codebase opens it and finds a thousand lines with no comments, no documentation, and no one alive who can explain the architectural decisions baked into the structure. Not because the decisions were bad—the AI might have made perfectly reasonable choices—but because nobody recorded why those choices were made.

This is what Torvalds means by “horrible from a maintenance standpoint.” And he’s right. In February 2026, Hackaday ran an article titled “How Vibe Coding Is Killing Open Source” that cataloged exactly this pattern: repositories flooded with AI-generated pull requests that introduced subtle bugs, broke backward compatibility, or added features that conflicted with the project’s architecture—all submitted by people who couldn’t respond to review comments because they didn’t understand what they’d submitted.

The problem isn’t that AI wrote the code. The problem is that no human took responsibility for it.

Torvalds’ Implicit Framework

Torvalds never published a blog post titled “When to Use AI and When Not To.” He doesn’t do frameworks or methodologies. But if you look at what he said in Seoul and what he did with AudioNoise, the framework writes itself.

The line isn’t “AI vs. no AI.” The line is disposable vs. durable. Code that’s meant to be thrown away can be generated however you like. Code that’s meant to last demands understanding. Torvalds drew that line instinctively, because he’s been drawing it for thirty years. The rest of us need to learn to draw it deliberately.

How Agentic Engineering Addresses His Concerns

Here’s where things get interesting. Torvalds’ critique was aimed at a specific workflow: one person, one prompt, one blob of generated code, no review, no documentation, no accountability. That’s vibe coding at its worst. But the field hasn’t stood still since he gave that talk.

The shift from vibe coding to agentic engineering—a term Andrej Karpathy introduced in early February 2026—directly addresses the maintenance problem Torvalds identified. Not by abandoning AI-generated code, but by wrapping it in the kind of engineering discipline that makes it survivable.

Persistent memory solves the context problem. One of Torvalds’ core objections is that nobody can explain why the code was written the way it was. With project memory files like CLAUDE.md, every AI session starts with full context about the project’s architecture, conventions, and past decisions. The “why” is documented before the code is generated, not lost after the chat window closes.

Structured review solves the accountability problem. In an agentic workflow, the developer doesn’t accept generated code blindly. They review plans before implementation, check implementations before tests run, and verify test results before merging. The human is the quality gate, not a rubber stamp. This is exactly how Torvalds runs the Linux kernel—every patch gets reviewed by someone who understands what it does and why.

Task decomposition solves the comprehension problem. Instead of prompting an AI to “build me a user authentication system” and accepting whatever comes back, agentic engineering breaks that into discrete, reviewable pieces: design the schema, implement the token flow, write the middleware, add the tests. Each piece is small enough for a human to understand. Each piece gets reviewed independently. The result is AI-generated code that a human can actually maintain, because the human was involved at every stage.

Session organization solves the oversight problem. When you’re running multiple agents on different parts of a codebase, you need to know what each one is doing at all times. Organized workspaces, labeled sessions, and persistent state mean you can pick up any agent’s work, review its output, and course-correct before it goes too far. The chaos that Torvalds warned about—code that nobody understands or controls—is a tooling problem as much as a discipline problem.

Practical Tips: Torvalds-Approved Vibe Coding

If you take Torvalds’ position seriously—and you should—the goal isn’t to stop using AI for code generation. It’s to use it with the kind of judgment that a thirty-year kernel maintainer would recognize as responsible. Here’s what that looks like in practice.

1. Classify before you generate. Before you type a prompt, ask yourself: is this code disposable or durable? If it’s a script, a prototype, or a visualization—vibe away. If it’s going into a production system, a shared codebase, or infrastructure—slow down and apply engineering rigor.

2. Organize your projects with intent. Every project you work on with AI should have a dedicated workspace with clear structure. In Beam, create a workspace per project with ⌘N and separate tabs for different workstreams. When you revisit the project next week, you should be able to see exactly where you left off and what each agent was doing.

3. Set up project memory from the start. Create a CLAUDE.md or equivalent file in your project root before your first AI session. Document your architecture decisions, your conventions, your dependencies, and your constraints. This is the institutional knowledge that prevents the maintenance nightmare Torvalds described. Every agent that touches your project should read this file first.

4. Review at checkpoints, not at the end. Don’t let an agent generate five hundred lines and then try to review them all at once. Break the work into stages. Review the plan. Review the implementation of each component. Review the tests. Use split panes in Beam (⌘D) to keep your review terminal next to your agent terminal. Catch problems early, when they’re cheap to fix.

5. Keep a maintenance journal. For any AI-generated code that’s going to live longer than a week, document what it does, why it was built this way, and what the known limitations are. This can live in comments, in a project wiki, or in your memory file. The point is that six months from now, someone—including future you—can open this code and understand it without having to reverse-engineer the original prompt.

6. Know what you can’t delegate. Torvalds hand-wrote the C components of AudioNoise because those components required understanding that can’t be prompted into existence. Security-critical code, performance-sensitive algorithms, and system-level interfaces are areas where you need to write the code yourself or, at minimum, understand every generated line well enough to explain it in a code review. If you can’t explain it, you shouldn’t ship it.

Key Takeaways

Torvalds isn’t anti-vibe-coding. He’s pro-knowing-when-to-use-it. That’s a more useful position than either “AI will replace developers” or “AI code is garbage.” Here’s what to take from his example:

• Torvalds used AI for Python visualization code and hand-wrote the C components himself. That’s not hypocrisy. It’s a clear-eyed assessment of which code needs human understanding and which doesn’t.
• The maintenance problem is real and getting worse. AI-generated code that nobody understands is already straining open-source projects and production systems. Hackaday’s “How Vibe Coding Is Killing Open Source” captured a pattern that every experienced maintainer recognizes.
• The line is disposable vs. durable, not AI vs. human. Scripts, prototypes, and visualization layers can be vibe-coded freely. Production systems, shared codebases, and infrastructure demand engineering discipline—whether the code is AI-generated or not.
• Agentic engineering addresses the concerns Torvalds raised. Persistent memory, structured review, task decomposition, and organized workspaces wrap AI-generated code in the kind of process that makes it maintainable.
• The Torvalds test is simple: can you explain it, defend it, and predict its failures? If you can, the code is yours regardless of who (or what) typed it. If you can’t, you’re shipping a liability.
• Tooling matters. Organized workspaces, persistent sessions, and structured review environments aren’t luxuries. They’re the infrastructure that separates responsible AI-assisted development from the chaos Torvalds warned about.

The Slashdot headline got it wrong. Linus Torvalds isn’t vibe coding. He’s doing what he’s always done: using the right tool for the job and refusing to compromise on the code that matters. The rest of us would do well to follow that example.