Listen to this Post
Introduction: The Evolution of a Software Legend
For more than three decades, Linus Torvalds has remained one of the most influential figures in the technology industry. His creation of the Linux kernel transformed computing forever, powering everything from smartphones and cloud infrastructure to supercomputers and embedded systems. Yet the Linux creator surprised audiences at the Open Source Summit India 2026 with a simple but powerful statement.
I am not a programmer anymore.
Coming from the man who wrote Linux itself and later created Git, the statement reflects something much larger than a personal career shift. It highlights how modern software engineering is evolving. Leadership, architecture, code review, trust, automation, and increasingly artificial intelligence are becoming just as important as writing code line by line.
During an in-depth conversation with Dirk Hohndel, Torvalds discussed Linux development, Rust, AI-generated code, obsolete hardware, Git, kernel maintenance, and why programming languages alone cannot solve poor software engineering. His perspective offers a rare glimpse into how one of the world’s most important software projects continues to evolve without losing its core philosophy.
Linux 7.1 Prioritizes Stability Instead of Spectacular Features
Unlike commercial software that often markets major releases around flashy new capabilities, Linux continues to embrace gradual improvement.
Torvalds explained that Linux 7.1 is another example of continuous refinement rather than dramatic transformation. Since adopting Git as the kernel’s version control system years ago, Linux development has focused on incremental progress.
Instead of introducing risky, massive redesigns, maintainers constantly improve performance, compatibility, security, and reliability across thousands of smaller changes.
This disciplined development model has become one of Linux’s greatest strengths.
Every release builds carefully upon the previous one, minimizing disruption while ensuring long-term stability for billions of devices worldwide.
Artificial Intelligence Is Changing Kernel Maintenance
Although Linux development remains highly structured, artificial intelligence has introduced both opportunities and unexpected challenges.
According to Torvalds, AI systems have become increasingly capable of discovering genuine software bugs.
However, the same systems also generate enormous numbers of inaccurate reports.
Developers now spend considerable time distinguishing legitimate vulnerabilities from AI hallucinations.
Rather than speeding development immediately, AI initially increased workload by flooding maintainers with plausible but incorrect bug reports.
Only recently has AI begun producing more useful results than unnecessary noise.
This transition illustrates a broader industry trend where AI maturity depends heavily on human supervision.
The Stress Is Rarely Technical
When discussing Linux merge windows, Torvalds revealed that he processes approximately 200 merges within just two weeks.
That enormous workload might appear overwhelming.
Surprisingly, he says code itself is rarely the difficult part.
Programming mistakes can be fixed.
Human disagreements are far more complicated.
Torvalds admitted that personality conflicts, communication problems, and differing opinions create much greater stress than software bugs.
Even after decades leading one of the
I Am Not a Programmer Anymore
Perhaps the
He explained that he hardly reads code compared to earlier years.
Instead of actively developing new kernel features, his responsibilities center around reviewing pull requests, understanding architecture, evaluating design decisions, and coordinating maintainers.
He occasionally writes small patches.
However, these patches are typically suggestions rather than final implementations.
The actual subsystem maintainers review, modify, test, and ultimately integrate those ideas.
His work has evolved from software author to technical leader.
That transition mirrors the career path followed by many experienced software architects across the technology industry.
Understanding Intent Matters More Than Reading Every Line
Torvalds emphasized that explanations accompanying pull requests often matter more than the code itself.
Before accepting changes, he wants developers to clearly explain:
Why the change exists
Which problem it solves
How it affects the larger architecture
Why the proposed approach is preferable
Understanding design intent allows better long-term decision making than simply reviewing syntax.
Only when merge conflicts or unexpected build failures appear does Torvalds dive deeply into implementation details.
Removing Legacy Technology from Linux
Linux has earned its reputation for exceptional backward compatibility.
Nevertheless, Torvalds believes maintaining obsolete hardware forever eventually becomes unsustainable.
Linux 7.2 will officially discontinue support for x86 processors without hardware floating-point capability, including the decades-old Intel 486 SX family.
Similarly, support for aging networking technologies like ISDN and ATM continues to disappear.
The reasoning is practical.
Every outdated subsystem increases maintenance costs, testing complexity, and development burden.
Older Linux kernels remain available for enthusiasts maintaining vintage hardware.
Modern Linux, however, is focusing on the future.
NTFS Remains
One topic that generated laughter during the session involved Microsoft’s NTFS filesystem.
Torvalds humorously described NTFS support as a long-standing challenge.
Interestingly, two independent Linux teams currently maintain separate NTFS implementations.
Rather than immediately choosing one, Linux developers continue evaluating both approaches.
Competition sometimes produces stronger software than premature standardization.
Deep Analysis
Modern Linux kernel development depends on sophisticated automation rather than manual testing alone.
Clone the Linux Kernel
git clone https://github.com/torvalds/linux.git cd linux
Build the Kernel
make defconfig make -j$(nproc)
Check Code Formatting
./scripts/checkpatch.pl patch.diff
Generate a Patch
git format-patch HEAD~1
Apply a Patch
git am patch-file.patch
Search for Potential Memory Bugs
make C=1
Static Analysis
scan-build make
Run Sparse Analyzer
make C=2 CF=-D__CHECK_ENDIAN__
Inspect Merge Conflicts
git merge branch-name git diff
Verify Commit History
git log --oneline --graph
These tools demonstrate why Linux development depends heavily on automation, verification, peer review, and maintainers rather than individual programmers working in isolation.
Git and Email Remain
Despite rapid technological progress, Torvalds revealed that his daily workflow remains surprisingly minimal.
His primary tools include:
Git
Google Search
While many maintainers now incorporate AI assistants into their workflow, Torvalds prefers focusing on architecture and people rather than experimenting with numerous development tools.
His philosophy emphasizes simplicity over unnecessary complexity.
Rust Is Valuable but Not a Universal Solution
Rust continues gaining popularity due to its strong memory safety guarantees.
Nevertheless, Torvalds cautioned against unrealistic expectations.
Rust eliminates many categories of memory-related errors.
It cannot prevent poor software logic.
If developers misunderstand requirements or implement incorrect algorithms, Rust cannot magically correct those mistakes.
Programming language safety does not replace engineering judgment.
He also pointed out that
Since Linux remains primarily written in C, hybrid development introduces practical limitations.
AI Still Requires Human Judgment
Torvalds shared a balanced assessment of large language models.
Initially, Linux developers received overwhelming numbers of poor-quality AI-generated reports.
Many appeared technically convincing while describing nonexistent issues.
Investigating these false reports consumed valuable engineering time.
Today, AI has improved considerably.
Still, Torvalds insists every AI-discovered bug should include:
Human verification
Reproducible evidence
A proposed patch
Discussion with maintainers
Simply asking an LLM to generate bug reports is insufficient.
Responsible developers remain accountable for validating AI output.
AI Can Discover Embarrassing Security Problems
Despite criticizing AI-generated noise, Torvalds acknowledged that LLMs have identified several genuine kernel vulnerabilities.
Some of these bugs attracted significant media attention shortly after discovery.
Rather than blaming researchers or AI systems, Torvalds welcomed the findings.
Finding vulnerabilities, even embarrassing ones, ultimately strengthens Linux security.
His attitude reflects the open source philosophy that transparency produces better software.
AI Helps with Personal Projects Too
Torvalds ended the session with humor.
Outside kernel development, he occasionally uses AI for experimental personal projects.
One amusing example involved family travel photographs.
Whenever he visits new countries, he sends pictures to his children.
For unknown reasons, AI frequently inserts Godzilla into those images.
Although hardly a production use case, it demonstrates that AI can also be entertaining rather than purely practical.
What Undercode Say
Linus
Many developers still believe AI will eventually replace programmers. Torvalds presents a far more realistic picture. AI certainly accelerates certain workflows, but it also introduces false positives, hallucinations, shallow fixes, and maintenance overhead.
His experience reinforces a principle that cybersecurity professionals have understood for years: automation without verification creates new risks.
Equally important is his discussion surrounding Rust versus C. The debate often becomes emotional, with supporters presenting Rust as a complete replacement for C. Torvalds instead evaluates both languages pragmatically. Memory safety matters greatly, but software correctness extends well beyond memory management. Poor logic, incorrect assumptions, and architectural mistakes remain possible regardless of programming language.
Another significant insight concerns Linux governance. Modern open source success depends less on individual brilliance and more on distributed trust. Thousands of maintainers coordinate globally, allowing Linux to evolve without relying solely on its original creator. That organizational maturity is perhaps Linux’s greatest technical achievement.
The removal of obsolete hardware support also signals a healthy engineering mindset. Maintaining every legacy component forever ultimately slows innovation. Carefully retiring outdated code improves maintainability, reduces attack surface, and simplifies testing.
Torvalds’ continued reliance on Git and email is equally revealing. Technology leaders often chase every new productivity platform. Torvalds demonstrates that consistency and deep understanding frequently outperform constant tool switching.
His balanced perspective on AI should resonate across the software industry. AI is neither revolutionary magic nor useless hype. It is another engineering tool whose effectiveness depends entirely on responsible human oversight.
Perhaps the most meaningful statement from the entire discussion was not about Linux, Rust, or AI.
It was his admission that he no longer considers himself a programmer.
That reflects the natural evolution of engineering leadership.
Exceptional technical leaders eventually spend less time writing software and more time enabling thousands of others to build better systems.
Ironically, that may be the most valuable form of programming of all.
✅ Accurate: Linus Torvalds publicly discussed Linux 7.1, AI-assisted development, Rust, Git, legacy hardware removal, and kernel maintenance during Open Source Summit India 2026.
✅ Accurate: Torvalds has consistently argued that Rust improves memory safety but does not eliminate logical programming errors, making his comments consistent with previous public statements.
❌ Needs Context: While AI is increasingly used in Linux development workflows, it is not responsible for developing the Linux kernel itself. Human maintainers continue reviewing, testing, validating, and approving all production-quality kernel changes.
Prediction
(+1) AI-assisted code review will become a standard component of Linux kernel development, particularly for vulnerability discovery, patch verification, and regression detection, while human maintainers remain the final authority.
(-1) As AI-generated patches become more common, Linux maintainers will likely face an increasing volume of low-quality submissions, forcing stricter contribution guidelines and more sophisticated automated validation systems before code reaches the review stage.
▶️ Related Video (72% Match):
🕵️📝Let’s dive deep and fact‑check.
🎓 Live Courses & Certifications:
Join Undercode Academy for Verified Certifications
🚀 Request a Custom Project:
Secure, high-velocity infrastructure and disruptive technological engineering. Contact our engineering team for high-tier development and proprietary systems:
[email protected]
💎 Smart Architecture | 🛡️ Secure by Design | ⭐ Trusted by Thousands
References:
Reported By: www.zdnet.com
Extra Source Hub (Possible Sources for article):
https://www.facebook.com
Wikipedia
OpenAi & Undercode AI
Image Source:
Unsplash
Undercode AI DI v2
🔐JOIN OUR CYBER WORLD [ CVE News • HackMonitor • UndercodeNews ]
📢 Follow UndercodeNews & Stay Tuned:
𝕏 formerly Twitter 🐦 | @ Threads | 🔗 Linkedin | 🦋BlueSky | 🐘Mastodon | 📺Youtube
