Rust Daily

Like Duolingo but for Rust. Practice writing idiomatic Rust for 10 minutes a day without any AI not to lose your skills.

Comment

Inspiration

I have used AI coding assistants extensively since Codex became available. They have made me far more productive—but over time, I began to feel that I was losing some of my ability to write code independently.

One day, I turned off autocomplete, code generation, and every other form of assistance, then tried to write some code from scratch. For several minutes, my mind went completely blank. That moment made me realize that programming ability, like any other skill, needs regular practice.

Inspired by the idea of Atomic Habits, I wanted to create a small daily ritual for preserving and improving my programming skills: something I could use for ten minutes a day without becoming overwhelmed.

I tried several existing coding platforms, but most focused on algorithmic puzzles. They often reward reaching the correct output, even when the solution is difficult to read or unidiomatic. In Rust especially, a straightforward but ugly solution might take half an hour, while developing a clean, idiomatic one can take much longer.

I wanted something different: a “Duolingo for Rust” focused on writing small pieces of realistic, idiomatic code without AI assistance.

What It Does

The project is a daily Rust-learning platform built around short, focused exercises. Each lesson is designed to fit into a brief practice session while still resembling work that a Rust developer might encounter in a real codebase.

Rather than presenting isolated puzzles, the lessons are connected into larger story arcs. Across an arc, learners gradually build and improve a piece of software, seeing how individual concepts fit into a growing system. This creates a sense of progression while keeping each daily task approachable.

The exercises emphasize practical skills such as:

  • Ownership and borrowing
  • Type conversions and validation
  • Parsing and configuration
  • Collections and data transformation
  • Error propagation
  • Service boundaries
  • Request and response mapping
  • Writing clear, idiomatic Rust

The goal is not merely to produce code that passes tests. It is to develop the habit of writing Rust that is safe, expressive, maintainable, and pleasant to read.

How I Built It

I built the project as a solo developer using specification-driven development and codex. GPT-5.6 Sol was used to create feature specifications and conduct code reviews, while GPT-5.6 Terra was used for implementation. I first described the desired behavior and constraints, then used those specifications to guide the implementation and validation of each part of the system.

The application consists of a React and TypeScript progressive web app backed by a Rust service built with Actix. Lessons are maintained as canonical source files and processed through a validation and generation pipeline, helping keep authored content and the application’s runtime content consistent.

One of my most important requirements was that submitted Rust code must never run directly on the host system. User code is untrusted, so submissions are compiled and executed inside restricted, rootless Podman containers. This sandbox provides a clear security boundary while still allowing learners to receive useful compiler output and test results.

AI assistants helped me work across areas where I did not have equal expertise—from frontend development and curriculum tooling to container isolation and deployment. However, the experience at the heart of the product intentionally removes that assistance: when completing a lesson, it is just the learner, the Rust compiler, and the code.

Challenges I Faced

The greatest challenge was balancing realism with brevity. A ten-minute lesson must be small enough to feel approachable, but meaningful enough to teach something transferable to real software development. It is easy to create a short syntax puzzle; it is much harder to create a compact exercise that encourages sound API design and idiomatic Rust.

Another challenge was designing progression. The lessons needed to stand on their own while also contributing to a coherent arc. Each exercise had to introduce a manageable amount of complexity without breaking continuity with the domain types and software developed in earlier lessons.

Safely executing submitted code was also a significant technical challenge. The application must compile and test arbitrary Rust code while protecting the host environment. Building a constrained container runner required careful attention to isolation, resource limits, temporary workspaces, error handling, and useful feedback.

Finally, I had to resist allowing the project itself to contradict its purpose. AI made it possible to build the platform quickly, but the learning experience needed to encourage deliberate, independent practice rather than another form of code generation.

What I Learned

The most important thing I learned—from this project and many of my other side projects—is that AI assistants can give independent developers one of the most precious resources in the world: time.

A single person cannot be equally skilled in every conceivable field. Building a complete product can require frontend engineering, backend development, infrastructure, security, design, curriculum creation, testing, and deployment. AI assistants can provide support precisely where a solo developer lacks time or expertise.

As a result, projects that might never have seen the light of day can now be built within days or weeks. AI does not eliminate the need for judgment, taste, or technical understanding, but it can dramatically increase the range of ideas that one person can explore.

At the same time, this project taught me that productivity and skill preservation are separate goals. AI can help us build more, but we still need deliberate practice if we want to retain the ability to think through problems and write code ourselves.

Why I Am Sharing It

I originally built this platform for myself. I now use it every day, and I genuinely enjoy the routine: ten quiet minutes spent writing Rust, thinking carefully, and relying on my own understanding.

That experience became valuable enough that I decided to share it. Perhaps other developers also feel the tension between embracing AI-assisted productivity and preserving their independent programming skills. If so, I hope this project can help them build a small, sustainable habit—one lesson and one piece of idiomatic Rust at a time.

Built With

Share this project:

Updates