AudioNoise Proof: Linus Torvalds on Vibe Coding and 4 Rules
AudioNoise Proof: Linus Torvalds on Vibe Coding and 4 Rules ! Engineer reviewing AI-generated code Linus Torvalds is "fairly positive" about vibe coding for learners and hobbyists, but he calls it "horrible" for production maintenance.
Linus Torvalds is “fairly positive” about vibe coding for learners and hobbyists, but he calls it “horrible” for production maintenance. He proved the point himself: the Python visualizer in his hobby project AudioNoise was, in his own words, “basically written by vibe-coding” using Google’s Antigravity tool. His headline advice for developers is simple: experiment freely, but keep AI-generated code far away from anything you actually have to maintain.
TL;DR:
- Vibe coding is suitable only for low-stakes experimentation and should never be used for building maintainable, security-critical production systems.
- Trusting AI-generated code without inspection, re-prompting for fixes instead of manual editing, and lacking the ability to explain the code are key indicators of vibe coding.
- Prototyping with AI tools lowers barriers for beginners and accelerates exploration but requires rewriting and reviewing before deployment.
- Industry risks include untraceable logic, hidden vulnerabilities, technical debt, and debugging nightmares that threaten long-term maintainability.
- Teams should adopt verified AI workflows with clear specifications, independent testing, and human oversight, reserving core systems for carefully reviewed, human-written code.
BitruptBuild AI Software You Can MaintainBitrupt helps teams turn AI ideas into scalable, secure software through senior engineering and end-to-end custom development.Explore Bitrupt
Table of Contents
- What Did Linus Torvalds Say About Vibe Coding?
- What Is Vibe Coding, Exactly?
- Why Vibe Coding Works Well for Learning and Prototyping
- What Are the Production Risks of Vibe Coding?
- How Can Teams Adopt AI-Assisted Coding Safely?
- When Does Bitrupt Use Vibe Coding, and When Doesn’t It?
- Turning a Vibe-Coded Prototype Into Real Software
- Sources
- FAQ
What Did Linus Torvalds Say About Vibe Coding?
Torvalds framed his position with the bluntness he’s known for after four decades maintaining the Linux kernel. He described vibe coding as fine for experimentation but not for production, by comparing large language models to an earlier tool that reshaped programming: the compiler. Compilers, he argued, made developers dramatically more productive without anyone fully tracing every generated instruction. AI coding tools could follow the same arc, he suggested, but the hype around them right now outpaces what the technology can reliably deliver in a codebase other people depend on.
He put that philosophy into practice on AudioNoise, a small hobby repository built around a music visualizer. The README credits the tool directly, noting that the Python visualizer component was generated with Google’s Antigravity, and that Torvalds essentially “cut out the middle man — me.” That’s a notable admission from someone who has spent his career reviewing every patch that touches the kernel line by line.
A few things are worth keeping straight about that example:
- AudioNoise is a toy project, not anything resembling kernel code or production infrastructure.
- Ars Technica’s coverage emphasizes that Torvalds picked a low-stakes repo precisely because the cost of a broken visualizer is close to zero.
- Antigravity is built on the Windsurf codebase, and while coverage suggests it likely draws on a Gemini-family model, the README doesn’t confirm the exact model, so treat that detail as informed speculation rather than fact.
Multiple outlets picked up the same dual message, including The Register’s report, which underscores that Torvalds’ comments weren’t a one-off soundbite. They reflect a consistent stance he’s repeated across interviews: useful tool, immature hype.
What Is Vibe Coding, Exactly?
Vibe coding means prompting a large language model to generate code and running with the output, without stopping to read, test, or understand what the model actually wrote. The term describes a workflow, not a specific tool. It’s defined by what the developer doesn’t do: no line-by-line review, no independent verification, no real mental model of the logic sitting inside the file.
That’s the key distinction from AI-assisted development done responsibly. A developer using Copilot-style autocomplete, an AI IDE, or a tool like Antigravity is still doing AI-assisted coding when they read every suggestion, run the test suite, and reject anything that doesn’t make sense. Vibe coding skips that loop entirely.
Three things typically define whether a workflow counts as vibe coding:
- Trust without inspection. The generated code ships, or gets committed, before a human has actually traced its logic.
- Iteration by re-prompting, not editing. When something breaks, the fix is another prompt to the model rather than a manual patch.
- No requirement to explain the code. The developer couldn’t walk a colleague through the implementation if asked.
Tools like Antigravity, Windsurf, and Copilot can support either workflow. The tool isn’t the variable. The discipline around it is.
Why Vibe Coding Works Well for Learning and Prototyping
Torvalds’ more generous comments about vibe coding center on exactly the use case AudioNoise represents: something disposable, low-stakes, and driven by curiosity rather than deadlines. That’s not a small category. A lot of genuinely useful software starts as a throwaway experiment.
- Lower barrier to entry. A newcomer who can’t yet write a working parser can still get a functional prototype on screen, which builds confidence and keeps momentum alive during the hardest part of learning to code.
- Speed on disposable work. Quick scripts, one-off visualizations, and hackathon demos rarely need to survive past their first run, so the maintenance cost Torvalds worries about barely applies.
- Exploration without fluency. Someone testing an idea in an unfamiliar language or framework can validate whether an approach is worth pursuing before investing weeks in learning the syntax properly.
This is also where the compiler analogy holds up best. Nobody expects a junior developer to read every line of assembly a compiler produces, because the compiler’s behavior is deterministic and well understood. AI-generated code isn’t there yet, but for low-risk projects, that gap matters less.
Pro Tip: Treat any vibe-coded prototype as a sketch, not a blueprint. If the idea proves out, rewrite the core logic yourself, or with careful, reviewed AI-assisted development, before it goes anywhere near real users.
What Are the Production Risks of Vibe Coding?
Torvalds’ kernel-maintenance instincts are exactly why he draws such a hard line here. The Linux kernel’s own coding-style and process documentation exists to keep code readable and maintainable decades after the original author moves on. Vibe-coded software fails that test almost by definition, because no one, including the person who “wrote” it, necessarily understands its internal logic.
The specific failure modes stack up quickly:
- Maintainability collapses. Code nobody understands can’t be safely extended. Every future change becomes a guess.
- Debugging turns into archaeology. When a vibe-coded feature breaks in production, there’s no mental model to consult, only brittle patches layered on top of code whose provenance is unclear.
- Security holes hide in plausible-looking code. LLMs can hallucinate APIs, misuse authentication patterns, or quietly skip input validation, and confident-sounding code is easy to mistake for correct code.
- Hidden technical debt accumulates. Regression risk climbs with every unreviewed change, and backporting fixes across versions becomes far harder without a clear map of what the code was supposed to do.
Industry coverage of Torvalds’ comments repeatedly circles back to this same maintenance framing rather than any single catastrophic bug. It’s the slow accumulation of unreadable, unverifiable code that worries him most, the kind of debt that doesn’t show up until a production incident forces someone to actually open the file. Notably, Torvalds draws a related distinction: he’s more comfortable with AI handling routine, repetitive tasks like patch flow or backporting than with AI generating actual kernel logic, which tells you exactly where the line sits for him.
How Can Teams Adopt AI-Assisted Coding Safely?
The gap between vibe coding and disciplined AI-assisted development isn’t about which tool you use. It’s about what happens between the prompt and the commit. Practitioner guidance on what researchers call “verified vibe coding” points to a specification-first, verification-in-the-loop approach that keeps AI generation useful without letting it run unchecked.
A workable process looks like this:
- Write the specification first. Document expected behavior, inputs, outputs, and edge cases before any code gets generated. The spec becomes the thing you verify against, not an afterthought.
- Keep verification independent of generation. Don’t let the same model that wrote the code also write the tests that check it. Independent tests catch correlated blind spots that self-review misses.
- Gate everything through CI. Static analysis, unit and integration tests, and fuzzing should run automatically before generated code merges, the same way they would for human-written code.
- Reserve core systems for human-written code. Security-sensitive components, long-lived public APIs, and anything touching authentication or payments should stay firmly in reviewed, human-authored territory.
Secure-AI governance frameworks, like the ones covered in MARFI’s work on AI automation and governance, reflect the same underlying principle: generation and oversight need to be separate functions, not the same step.
Pro Tip: If you can’t explain a piece of AI-generated code to a teammate without opening the chat history, it isn’t ready to merge. That single test filters out most of the risk Torvalds is describing.
When Does Bitrupt Use Vibe Coding, and When Doesn’t It?
Bitrupt treats vibe coding the way Torvalds does: a legitimate tool for exploration, never a substitute for engineering discipline on client work. Prototypes and proofs of concept can move fast with AI generation, but anything shipping to production goes through specification review, independent testing, and a security audit before it earns a place in a real codebase.
That split shows up in how Bitrupt structures engagements. Teams that want a fast, disposable prototype get one. Teams that need that prototype turned into something maintainable get production hardening instead, with senior engineers who read the code rather than trust it. AI is a tool that speeds up implementation. It doesn’t replace the judgment required to know what “done” actually means.
— Usama
Turning a Vibe-Coded Prototype Into Real Software
If you’ve got a working demo built with an AI coding assistant and you’re wondering whether it can survive contact with real users, that gap can be addressed with proper engineering discipline. The Vibe Coding service takes AI-generated prototypes and rebuilds the parts that matter, security, error handling, test coverage, so the finished product can actually be maintained by a team, not just admired in a demo.
For teams earlier in the process, the AI Readiness Workshop runs one to two weeks, fully remote, and gives your engineers a disciplined framework for using AI tools without accumulating the technical debt Torvalds warns about. And if your roadmap includes something bigger than a single prototype, like an LLM-powered feature or a production data pipeline, Bitrupt’s AI and data engineering team builds it with senior engineers from day one. Book a call to walk through what you’ve built and figure out what it takes to make it production-ready.
Sources
- Linus Torvalds: Vibe coding is fine but not for production
- Even Linus Torvalds is trying his hand at vibe coding
- Kernel coding style and maintenance principles
FAQ
What Does Linus Torvalds Think of Vibe Coding?
He’s “fairly positive” about it for newcomers and experimentation, but calls it “horrible” from a maintenance standpoint when used for production software.
Does Linus Torvalds Use AI to Code?
Yes. He used Google’s Antigravity to generate the Python visualizer component of his hobby project AudioNoise, describing it as basically written through vibe coding.
Is Vibe Coding Actually Coding?
It produces working code, but skips the review, testing, and understanding that define disciplined software development, so most engineers treat it as a distinct, riskier workflow rather than standard AI-assisted coding.
Why Did Vibe Coding Get Criticized for Production Use?
Because AI-generated code that nobody has reviewed tends to create maintainability, debugging, and security problems once it’s part of a live system, the same concerns that shape kernel maintenance principles Torvalds has followed for decades.
