Programming at the Edge of my Abilities for three months straight
Recurse Center Return Statement
I’ve just completed one of the most transformative periods of my life. Three months programming at the edge of my abilities — and beyond — during a batch at Recurse Center, a self-directed programming retreat, living in NYC.
Why?
Late last year, I was interviewing with one of the big LLM labs. They needed the position to start in January 2025 but the interview process would take some time. Given Germany’s employment laws (which I usually don’t complain about) that require a three-month notice period, I had to make a call to either hand in my resignation before having a secure offer or to drop out of the application process.
Since you’re reading me rambling about Recurse Center, you can imagine how the story ended. After six rounds and in the last 40 out of more than 2500 applicants, I didn’t make the cut.
So on January 1, 2025, I found myself out of a job and without a clear path forward. I didn’t want to rush head first into some next job but make a deliberate step and make use of the newly found free time I found on my hands.
“Learning to Code” on nights and weekends to make up for my lack of traditional computer science education was a big part of my life even for the two years where I was already working as a software engineer. But now, I could take a couple of weeks to focus on this full-time.
That’s where I found Recurse. The first thing that excited me was the batch length. Three months — a time I wouldn’t have been able to justify to myself. Recurse was a convenient “excuse” to take that much time in between jobs.
I had many more goals for my batch than I could reasonably accomplish. Go deeper on ML, Agents, learn, Swift, Rust, Systems Programming, Go, Compilers, Operating Systems, distributed algorithms, WASM, build libraries, applications, write regularly, and much, much more.
Once the batch started, this list quickly slimmed down. I wanted to build something that impressed myself and that was best achieved by focus rather than exploration.
Rust, however, as a general-purpose technology, seemed like a vehicle that would allow me to focus, force me through many of the computer science concepts I wanted to learn anyways, yet allow me to explore things through the application domains.
It was also nice that there were a lot of other Recursers also interested in Rust. The quest didn’t feel alone and I had accountability partners for slowly chewing through the (excellent) Rust book, “The Rust Programming Language”.
I ended up building a blockchain, an interpreter for the Monkey programming language, a couple of distributed consensus algorithms using Jepsen’s Maelstrom framework for testing and made more than 15 open-source contributions in Ruff and UV, Python tooling written in Rust.
During this, I’ve experimented a lot with different learning methods. Starting with training wheels that I would gradually remove worked really well for me. In the beginning, I built small projects and used a lot of LLM help. To gain muscle memory I retyped instead of copy-pasting. This proved useful to learn what correct Rust code looked like, but I was missing the other side of the coin. What doesn’t work and why?
Another thing was that, because I lacked seniority in Rust, I could not judge the quality of the LLM output well. Is that idiomatic Rust or overengineered, verbose slop that just happens to work?
I addressed these issues by resorting back to good old books. Building Bitcoin in Rust is a fun guide through a blockchain implementation and the architecture was way more thought through than what LLMs would spit out.
I also enjoyed that I was learning new concepts alongside building muscle memory in the language. Distributed networking, mempools, block validation, and how to avoid transaction duplication, just to name a few.
Every now and then, however, I found myself slipping into mindless retyping of what I was reading instead of actually comprehending it.
This led me to an alternative approach. Working with Maelstrom, a repository and testing framework for distributed systems with a reference in Ruby, I found myself paying much more attention. I could read it as pseudo-code, but implementing it in Rust forced me to think through what Ruby abstracted away but must be made explicit in Rust.
I later did the same when building an interpreter for the Monkey programming language following “Building an Interpreter in Go.”
These endeavors really made me feel how my skills grew. In the beginning, I needed plenty of time ping-ponging with Claude or Googling how to implement something in Rust but after a short while, I was cruising in Rust whilst at the same time wrapping my head around lexing, parsing, and abstract syntax trees.
In the second half of my batch, I focused on open-source work. Contributing to some projects with real-world impact would have my code go through (1) rigorous review and (2) serve as proof to myself that I can write production Rust.
At the end of my batch, I had 15 merged PRs across Ruff and UV and learned a lot about static code analysis, Python control flow (who knew you can have an else after loops), building high-performance developer tools, and idiomatic Rust.
These were the main quests of my Recurse batch. Looking back at my checkins — almost daily posts on an internal bulletin board — I wasn’t satisfied with my progress day to day. Most days ended with something not working, unfinished, or blocked.
But I guess that is how it feels to work at the edge of your abilities. Looking back at what I’ve achieved during my batch I’m impressed by and proud of myself. I’ve managed to tick all the boxes that were important to me.
And still, I managed to follow numerous side quests. I’ve made it through substantial parts of MIT 6.172, Performance Engineering of Software Systems, a course that convinced me that computers are really marvelous machines. I presented my programs during talks. I held a session on MLOps and organized another with friends a start-up presenting their LLMOps dev tool.
The biggest sidequest was me writing a paper with folks at the AI Safety Institute of the German Aerospace Center. This doesn’t seem like it fits into the Rust narrative and indeed it doesn’t. While waiting for my batch to start, I’ve continued the work I’ve done in my master thesis with the goal of publication. Maybe that is something that would make me stand out more if I reapply for ML research roles.
In all honesty, I’ve majorly underestimated the amount of work still required and it dragged on as I focused on programming instead of research during batch only working on it after hours. But I’m happy to say that mere hours before writing this sentence, I got off a call with my supervisor and we will submit the manuscript soon.
While my main focus was programming, the work I’ve put into ML and MLOps over the last few years felt pretty validated as I had peers coming to me with their questions and asking for help when they were stuck implementing attention heads, speculative decoding, or had problems wrapping their head around some maths.
I really enjoyed the vibe and diversity of the batch. People were diverse in backgrounds, gender, age, and experience. I learned a lot through this mix.
New York as a city and its tech scene felt really diverse, too. I’ve visited events like WordHack, Chinatown.JS, and Rhizome which featured whimsical art projects by “creative technologists” that really inspired me.
While I wasn’t writing for my paper too much, I managed to write a weekly newsletter. At least during the first half of the batch. It really is simpler to write when you have many new impressions. But I’ve reached the edge of my productivity alongside the edge of my abilities. For the second half of my batch, I decided to drop writing to allocate more time to Rust and pair programming.
Two projects I paired on and really liked were a multiplayer browser-based capture the flag game with websockets connected to a Rust backend and a space invaders clone that used folders on your desktop — turns out, a game engine is mainly a glorified while loop and you can shell out to AppleScript to programmatically change folder positions on your desktop.
Recurse Center has been an enormously transformative experience for me. I’ve learned a ton and gained tremendous confidence in what I can already do and the ability to learn fast if necessary. Programming to me just became ever more joyful and I’m truly thankful for this experience, the city, the things I learned, the people I’ve met, my roomies in Ft. Greene, making new friends, and spending time with good, old ones who since moved to NY.
I started this post by describing my situation and how I ended up at Recurse Center. I don’t know if I would have had the courage to quit my job to attend and sure, working at Big Lab xyx would have been cool, but I’m really happy the story went the way it did because I bet on myself and ended up as a much better version of myself than before.
All else will follow…I’m sure of that.
P.S.: Two things:
If you think Recurse could be something for you, apply! It’s great.
I’m still in the market for a job, productive at the intersection of SWE and ML, passionate about developer tooling and care about programming, and interested in something post-PMF. Rust is a bonus. If you know something, let me know.