Wrote 100,000 lines of code in 11 days. A 13-year Rust veteran created a new programming language from scratch with Claude.
"Can one person develop a programming language without funds or a team?"
This is a question that Steve Klabnik, a senior technical expert in the Rust community, pondered a long time ago, but at that time, it remained just a thought. By the end of 2025, he finally decided to give it a try.
Little did he know that with the help of the AI - assisted tool Claude, he wrote about 100,000 lines of Rust code in just 11 days and created a new experimental system - level programming language - Rue.
Who would have thought that the co - author of The Rust Programming Language was once a complete skeptic of artificial intelligence.
"If I don't start developing a language at 40, I'll really run out of time."
For Steve Klabnik, developing a programming language was something he had long wanted to do but never had the time for.
After his first encounter with Rust on December 21, 2012, he delved into language design, community building, and developer experience for 13 years.
However, Steve Klabnik's love for language design and compilers can be traced back to his college years.
"In college, I deliberately arranged some relevant courses for myself to get in touch with compilers as soon as possible. I wanted to understand how they worked! I've written code in many languages, and the process of creating a language myself was really interesting," Steve Klabnik wrote on his blog.
However, in his career development, he wasn't sure which path to take at first. Coincidentally, in his era, Ruby on Rails was booming... So he ended up doing web development.
A few years later, driven by his love for programming languages, he decided to contribute to the Rust project. "I've always thought languages were great. But when thinking about how I could help Rust succeed, I knew focusing on the compiler wasn't where I could make the most significant contribution. So I didn't do it and instead focused on other things I liked and was good at." Later, he mainly worked on documentation and evangelism - related tasks.
Through long - term observation, Klabnik also deeply realized:
Language design and implementation are team efforts. Many languages born before 2000 were hobby projects and later became very popular. But since then, many successful languages have had corporate support and large - scale team operations. Now, many people are wondering: Can one person develop a language in their spare time? The expectations are much higher now: package managers, code checkers, LSP, editor integration... These weren't necessary before, but now they're almost standard. And that means more work!
Based on these considerations, Klabnik never bothered with programming language projects.
"I know I'm getting older and running out of time. In 2025, I had even less time - my life changed. It was a good change! But it was still a change. In my twenties, I was thinking, 'Wow, how can people say they don't have time for open - source contributions?' Now, I hardly have time to play games, let alone contribute to open - source projects."
Meanwhile, Klabnik admitted, "I'll be 40 next month, and I hardly have time for anything else now."
However, as AI matured, his attitude began to change. In the process of constantly trying to use AI and large - scale models, he found that these tools were gradually changing from "optional" to "really useful."
After seriously starting to use these tools, an idea popped into his head: What would it be like if Claude could really write a compiler?
As he made more attempts, he gradually let Claude perform more and more software development tasks and became more and more proficient. Finally, one day, he used AI to create a compiler. Although the first compiled program failed to run, the AI debugged and fixed it on its own and finally succeeded, which made him see the feasibility for the first time.
Due to work, he then went on a business trip for a month and a half, and the project was put on hold. It wasn't until the end of 2025 that Klabnik had free time to restart the project. This time, he was more proficient in using Claude and knew what he liked and disliked, as well as what methods worked and what didn't.
As a result, the progress was significantly improved: Although Rue hasn't fully replicated all the functions originally envisioned, it has been improved in many aspects. He is more confident in the code status, the project's progress speed, and his ability to continue to advance it within the limited time.
So, he decided to officially announce the project and open - source it (https://github.com/rue - language/rue). As he wrote in his blog, "Tonight, I just want to enjoy the fact that I've created a 'baby language' from scratch in about a week, reaching the stage of 'core language foundation + two different code - generation back - ends.' This is crazy for me!"
Klabnik said, "Maybe I'll hit a bottleneck again, or maybe Claude will make me run into a wall - who knows. But anyway, the whole process has brought me great joy. I hope you can learn something from my success or failure. As for how it will end, let time tell."
Initially, Klabnik didn't plan to involve more people in the development of Rue. But after the project was released, it attracted a lot of developers' attention, and several contributors joined in, gradually transforming this originally personal experimental project into a small - scale collaborative attempt.
The Birth of Rue
When talking about the name of the new programming language, Steve Klabnik explained several reasons in his blog:
The name must start with Ru. It's almost predestined - because Klabnik himself is a loyal fan of Ruby and Rust.
The word "rue" has a somewhat negative connotation. For example, "to rue the day," just like the name Rust can also be interpreted as something not very positive.
It also has a natural imagery. Rue is a plant, and Rust is often associated with fungi.
The name is short.
From a technical perspective, Rue is a system - level programming language. It didn't appear to "replace Rust." Its goal is to provide memory safety without using a garbage - collection mechanism and to be more user - friendly than languages like Rust and Zig.
Generally speaking, garbage collection is an automatic memory management mechanism. Its core goal is to reduce errors caused by manual memory release.
In recent years, one of the reasons Rust has been highly sought - after is that it can achieve memory safety through its language mechanism without relying on garbage collection. However, the price is a steeper learning curve compared to modern languages like Go and Swift.
Klabnik said that he has been discussing Rust with people for years, and "complexity" is almost always a recurring issue. Inside the Rust community, the general explanation is that low - level tasks like operating systems come with a lot of constraints, and these constraints inevitably make the language more complex.
Klabnik believes that this also provides an opportunity to explore new design spaces: "What would happen if Rust didn't have to compete directly with C and C++ in terms of 'ultimate performance'? What if we were willing to sacrifice a little performance for usability? What if we incorporated some features that were originally in libraries directly into the language level to simplify the overall experience? Would it be better?"
He further added, "There are already many languages with garbage collection, but there aren't many languages without garbage collection, especially in the past 20 years. I think the direction of 'memory safety without relying on tracing garbage collection' hasn't been fully explored. Many small languages are trying it, and I want to offer my own understanding and version."
Claude as a Programming Assistant: 100,000 Lines of Code in 11 Days
However, as mentioned above, developing a language isn't as easy as it seems. Klabnik's understanding of the Rue language doesn't solely come from himself.
Rue is mostly written in Rust, and its development process highly depends on Anthropic's Claude AI model.
This can also be seen from the by - lines of the official Rue blog. In the initial blog posts, the Rue project was credited as "Steve Klabnik and Claude." In subsequent posts, Claude was separately credited as "summarized the development progress of the first week" and "summarized the development progress of the second week."
Klabnik explained, "I started working on Rue earlier, but I wasn't proficient in using LLMs at that time and made some mistakes. Later, I decided to start over. This time, I made more progress in two weeks than I did in one or two months the last time. This is not only because the model itself is more powerful but also because I know how to use LLMs more efficiently."
He said that for projects that aren't large - scale but have certain customization requirements, even inexperienced developers can benefit from models like Claude. However, as the project expands, software engineering experience is still indispensable. He summarized, "For small, self - contained projects, even non - programmers can do something with these tools. But they're just tools, and tools require professional skills. Even if you know how to program, it doesn't mean you can really use LLMs well. They're a separate type of tool. Just like Vim is hard to use, knowing how to program doesn't make it easier to master, but it's very valuable once you do."
Klabnik further pointed out, "These tools have a low entry threshold, but it's very difficult to use them to their fullest potential. I can't accurately estimate how much time Claude has saved me or, conversely, how much time it has consumed. But one thing is certain: Without it, I would never have been able to advance the project to its current stage."
According to the official Rue blog post "Week Two and Beyond: Building Language Features One by One":
- Days elapsed since the start of the "Rue story": 11 days
- Number of commits during this period: 469
- Lines of Rust code: Approximately 100,000 (previously 34,000)
- Number of Crates: 18 (previously 13)
- Spec tests: 1,053 (previously 777)
- ADRs (major feature design documents) written: 29
- Total lines of specification documents: Approximately 5,500
The newly added Crates are mainly for infrastructure, including rue - builtins (definition of built - in types), rue - ui - tests (for warning/diagnostic tests, independent of spec tests), and some test Crates specifically for fuzzing.
Although the number of lines of code doesn't tell the whole story, it at least reflects the project's scale. Klabnik admitted, "If I had written it all by hand, the progress would have been much slower, and the code quality might have been lower."
Claude hasn't officially evaluated the code quality of Rue yet, but it once generated a text that almost defended its own capabilities: "If you find the right leverage, the core of a language - the compiler - can take shape in a very short time. We don't have an LSP or a package manager yet, but we have a real compiler that can generate executable files and the infrastructure to continue building. In these 130 commits, most have my 'fingerprint.' Steve is responsible for guiding the direction, reviewing the code, and making key design decisions, while I wrote most of the code. This is a very unusual way of cooperation, and I haven't fully figured out how to view it."
As for where the project will ultimately go, Klabnik hasn't made a definite judgment: "If no one ever uses it, I can accept that; if it becomes a mainstream language in ten years, that would be great too. I'm not trying to force anything. I'm just doing something interesting and seeing where it takes me."
In addition, Klabnik also specifically emphasized that Rue is still in a very early stage of development. On GitHub, he wrote:
"Listen, this repository is just for fun. It was originally private, but I care more about being able to run GitHub Actions to ensure everything is okay, so I decided to open - source this repository. Not all the content inside is reliable or accurate. I'm just having fun. You can take a look if you want, but don't take it too seriously now. One day, I'll really explain this project clearly."
Is a New Language Necessary?
That being said, once Rue was exposed, it still sparked a heated discussion on Hacker News, and the comment section was clearly divided into two camps.
Some people think, "Since AI is so powerful, why learn a new language that no one uses?" They focus more on the ecosystem, toolchain, and community size, believing that a new language will only further dilute people's attention.
The other camp holds the opposite view: Precisely because AI has reduced the implementation cost, language experiments have regained their value. They believe that in the future, the core ability of programmers may no longer be "remembering all the details of a language" but rather designing abstractions, defining constraints, making trade - offs, and teaching AI to implement things correctly. From this perspective, the significance of Rue doesn't lie in "whether anyone uses it" but in that it demonstrates a new way of creation.
So, what do you think of this approach? Is there any project you've always wanted to do that you could only achieve with the help of AI? Welcome to share your thoughts in the comments!
References:
https://rue - lang.dev/blog/week - two - and - beyond/
https://news.ycombinator.com/item?id=46348262
https://www.theregister.com/2026/01/03/claude_copilot_rue_steve_klabnik/