Learning a new programming language used to mean working through tutorials, reading documentation, and spending hours debugging basic syntax errors. Revisiting a language after years away meant searching through Stack Overflow, staring at updated syntax and mumbling "how did I do that again?"
AI coding agents have changed this fundamentally. They don't replace learning—they accelerate it by providing context, working examples, and immediate feedback.
Building a CLI tool in Rust with Cursor
I recently built a CLI tool for our development environment to learn Rust. I've heard about Rust for years—its memory safety, performance, and modern tooling—but never had a compelling reason to dive in. Building an actual tool I needed, specifically something that Rust was a reasonable choice for, gave me that reason.
Cursor wrote most of the code. But here's the key: I wasn't just copying and pasting. I was following along, understanding what it was doing as it set up the project structure, configured the build system, and wrote the implementation. When Cursor suggested using Result<T, E> for error handling or introduced me to Rust's ownership model through actual working code, it clicked immediately because I could see it in action.
Having programmed in many languages over the years made this much easier. I know what functions are. I know how packages work. I understand loops, error handling, and module systems from a dozen other languages. When I see Rust's version of these concepts, I can pattern-match: "Oh, that's like Go's X" or "That's similar to JavaScript's Y but with more type safety."
LLMs excel at filling in these blanks. They show you the Rust way to do something you already know how to do conceptually. Instead of spending hours reading about cargo, modules, and crates, Cursor just built it and I watched it happen. The learning came from seeing patterns I recognized expressed in a new syntax.
Am I a Rust expert? Far from it, but I'm much more confident that I could very quickly become productive on a new team.
Refreshing C# and ASP.NET after 20 years
I haven't touched ASP.NET and C# in about two decades. Back then, I was working with Web Forms, manually wiring up controls, and dealing with ViewState. I also built a time-lapse photography application with my Canon DSLR using C#. This small utility proved the language was versatile beyond web development.
This past weekend, I wanted to prototype a small web app and decided to use C# again. Modern ASP.NET MVC is mostly unrecognizable from what I knew. But that's where Cursor came in. I described what I wanted to build, and it scaffolded a modern ASP.NET Core MVC application with routing, controllers, views, and dependency injection.
As I watched it work, muscle memory returned. The syntax of C# came back quickly—if you squint hard enough it's practically TypeScript1. But the framework patterns were new. Cursor filled in those gaps, showing me how modern MVC conventions work, how middleware is structured, how dependency injection replaces the old patterns I used to write manually.
I didn't need to relearn C# from scratch. I needed to see how the ecosystem had evolved. The coding agent provided that bridge between my old knowledge and the modern conventions.
Why years of experience makes this work
Here's what makes learning with AI effective for experienced programmers: you already have the mental models. You know what you're looking for. When a coding agent suggests a pattern, you can evaluate whether it makes sense because you've seen similar patterns before.
When Cursor writes a Rust match statement, I recognize it as a switch/case with pattern matching and exhaustiveness checking. When it sets up ASP.NET controllers, I see they're similar to Ruby on Rails controllers—just with different routing conventions and C# idioms.
Beginners learning their first language with AI face a different challenge. They don't have those reference points. They need to build the conceptual foundation alongside the syntax. But for experienced programmers jumping into a new language or refreshing a dormant one, AI agents are powerful accelerators.
You're not learning programming—you're learning the particular way this language and ecosystem express concepts you already understand.
The practical workflow
Here's what this looks like in practice:
-
Start with a real problem: Not a tutorial or a toy example. I needed a CLI tool, so I built it in Rust. I wanted to prototype an app, so I used C#.
-
Let the agent scaffold and write: I describe what I want. Cursor generates the structure, sets up the build system, and writes initial implementations. I read everything it does.
-
Ask questions when patterns don't click: When I see something unfamiliar, I ask. "Why use
Box<dyn Error>here?" or "How do I get this NuGet package installed as a dependency?" The agent explains in context of the actual code it just wrote. -
Make small changes myself: Once I see the pattern, I try variations. Can I refactor this function? Can I add a new route? These experiments cement the learning.
-
Build on what works: Each successful piece becomes a reference. When I need similar functionality later, I know where to look in my own code—and I understand what I'm looking at because I saw it built.
What this isn't
This isn't passive learning. You can't just ask an AI to build something, deploy it, and claim you know the language. You need to engage with what's being written, understand the choices being made, and build your own mental model of how the pieces fit together.
This also isn't universal. If you're learning your first language, you need to build foundational concepts that coding agents assume you have. But if you already know several languages and want to learn another—or if you knew a language years ago and want to refresh your knowledge—AI agents are incredibly effective.
The takeaway
Learning a new language or revisiting an old one used to mean days or weeks of ramp-up before you could be productive. AI coding agents collapse that timeline. Not because they replace understanding, but because they provide working examples and immediate context for concepts you already grasp abstractly.
The key is having those reference points—the years of experience across different languages that let you say "I know how to do this conceptually, show me how it's done here." When you have that foundation, coding agents become incredible learning tools.
Build something real. Use an AI agent to help. Read every line it writes. Ask questions. Make changes. That's how you learn a new language in 2025.
Footnotes
-
Shout out to Anders Hejlsberg, he knows how to design 'em! ↩