What I built at Recurse Center - a 12 week programming retreat (Return Statement W2'26)

I just finished my 12-week programming retreat at Recurse Center. As is tradition, we write "return statements" to reflect on the time - what we did, built, and learned.

What is Recurse Center and why join?

Recurse Center is a 6-12 week programming retreat run in overlapping batches. It's similar to what I imagine a writing retreat is like (I've never been) but for programming instead.

It's largely self-directed in what you focus and work on but there's a lot of added structure and accountability in the form of faculty-led career / brainstorm / reflection sessions, weekly checkins and presentations, and recurser led workshops / clubs / groups on all sorts of topics - both tech-related and otherwise.

Some examples of these topics include game dev, creative coding, distributed systems, word puzzles, and writing but there are many more and you're free to create whatever events you want.

I'm largely a solo, self-directed person - that's where I feel most comfortable and empowered. But I realized that could require a lot of discipline while on my parental leave and I may just default to playing video games / tv while I watch the kid which didn't seem very fulfilling to me. Plus I figured I could always do solo retreats, this was an opportunity to do a full RC batch while I had the time and bandwidth to attend.

So the main reasons I wanted to join were:

• Structure + Accountability - Enough to keep me engaged and working on stuff but still allow me to be self directed.
• Community + Collaboration - A unique group of individuals who are also deeply excited about tech and find it fun and want to spend 6-12 weeks (or more!) focused just on this.

What I planned to build

I had an idea that what I planned to build coming into the batch and what I'd actually focus my time on might be different so I logged my plans for posterity.

Here's what I planned to build at Recurse Center going in:

I figured the actual projects could (and should) change as I got new ideas but there were 3 main themes I wanted to dive into to feel like I really made progress in these 3 months. Copying these from my other post:

• Video games and simulations. I've always wanted to build a game and have dabbled with game engines and simulations in the past but never built one. By the end of the batch, I want to have a working game to help me learn about the space and process.
• Web fundamentals. I've done a lot of web programming over the years but I haven't gone deeper. I want to build a web server from scratch and play around with core libraries - thinking the likes of Datastar, HTMX, and CinderblockHtml.
• Applied AI. AI is here to stay and I use AI daily as a software engineer. I don't want to just be a consumer of this tech, I want to understand how it works under the hood and start building / producing it.

What I actually built

The things I built all roughly align with the buckets I set out at the beginning of the batch. But the form they took was different than I expected.

Applied AI for Engineering

Where I did the most work was in applying AI for engineering or agentic engineering. I saw the rise of agents and how good they were getting at work and in my side projects and really felt getting good at this would pay dividends short and long term.

So I dove in and started researching / experimenting with how to leverage this technology to my ends in a way that felt good to actually use.

Things I built:

• A set of agent skills for building quality software fast
• Phase Golem - an AI orchestrator written in Rust. I got annoyed with agent's small context windows and manually clearing context, making them run the next phase of a workflow so built Phase Golem to be that outer wrapper.
• Task Golem - an AI task tracker written in Rust. Eventually I got comfortable enough with Phase Golem to allow it to run over night but I noticed that tasks would finish with followups and never be logged. So I built a simpler version of a task tracker like beads to serve that purpose. Now as agents run, if they have a followup that's useful but shouldn't be done right now, they can just log the followup via a cli call.

I also moved to a Linux-based, terminal-focused computer setup. I found myself in the terminal a lot more with my agents and was intrigued by some of the terminal setups I saw other recursers using. So I tried it out and now run most things directly in terminal:

• Fedora - More updates than Debian, more stable than Arch
• Sway WM - Auto tiling and workspaces for easy hotkeying
• Ghostty - Modern and solid terminal
• Zellij - Easy to use, capable, and portable multiplexer
• Neovim - Modern, terminal-native editor

I also started to use Vim. It took a few days to get decent and a few weeks to be up-to-speed but now I like it, makes me feel more like a wizard. I'm using it in my editor, terminal (where possible), notes app, and even for Chrome browsing with Vimium.

Web Systems with Rust

I've always been focused on backend web systems. I like those kinds of problems and architectures and there's typically someone who wants to pay me for that expertise.

What I didn't expect coming in was to build these with Rust. I've previously used a lot of F# and was moving more towards C# and TypeScript when the batch started.

But I wasn't that excited about either of those and it felt like there was a missing programming language for doing what I wanted. So when another recurser mentioned that Rust was a great high-level language, I got nerdsniped and decided to investigate further.

My investigations revealed that Rust can be a good high-level language if you follow some guidelines. I've been calling this High-Level Rust:

• Type-first domain modeling - Use Rust's expressive types to model the domain and make invalid states unrepresentable.
• Domain-Driven Design with Arc<dyn TRAIT> at the top-level for service references. This gives the ergonomics and structure of dependency injection I'm used to building systems with, without the need for Rust generic type annotations scattered at every level.
• Functionalish logic with clones - Use pipes and clones vs mutations. Just be sure the clones are cheap with something like LightClone.

With this approach, I've built several systems:

• CloudSeed Rust - a fullstack Rust boilerplate. After a few weeks with the language I decided to close CloudSeed F# and move to Rust.
• My Labs Server - Built with CloudSeed, each experiment is a vertical slice.
• LightClone - A crate providing compile-time safety for O(1) clone operations to provide guardrails when writing High-Level Rust.
• Moved my blog from C# to Rust - it's 4x faster and uses 4x less memory

I've really enjoyed Rust and it's become my go-to for side projects. It may also become a goto at work at some point though I think people building the high level apps I like to build tend to stick to other langs and those that know Rust well will likely balk at my approach to High-Level Rust. But perhaps one day.

Networked Games

I started working on games early in the batch but it wasn't until near the end that I started getting around to the networked parts.

• AI Token Clicker - An endless clicker themed around burning tokens. This was the first "full" game I've built and I realized how much work goes into polish, "JUICE", and tweaking.
• Snake Game - Single player and multiplayer snake games built with Rust and Datastar.
• Planet Box - A planet-wars style simulation where each planet is controlled by an AI in a sandboxed wasm worker thread. Totally inefficient but built for a creative coding prompt at RC and I'm really happy with how it turned out.

I built my labs server to host these games so people could easily find / play them. I think it's served as a nice culmination of all my themes - it's agentically engineered, built with CloudSeed Rust, and hosts my networked games.

Writing

I also wrote a lot while at RC. For the past few years I've written ~100 posts a year. While at RC, I wrote 45 which is at pace for ~180. I won't hit that of course as my writing will slow down as I go back to work but still lots of writing!

This also led me to building a few smaller projects:

• An active view counter for my blog - which you should see in the top right corner
• A just command for uploading images to my CDN and getting the URL so I can easily embed images in my posts
• Improving my diagram agent skills to produce clearer artifacts

Advice / Learnings from Recurse Center

Here is some advice / learnings I have from RC that I think might be useful to other folks going into RC.

• Follow your curiosity - Be open to inspiration from others and listen to what you actually want to work on. The big push from RC is to get outside your comfort zone, collaborate openly, and do things you might not have otherwise. So be open to that, even if you don't do it the full time. Two of the biggest changes in my workflow (moving to Rust and the terminal) came out of being open and curious.
• Be systemic - Following your curiosity can also lead to shiny object syndrome where you are really busy but not actually building / shipping anything. Having set work times and goals each day/week/month was a great way to stay focused and maintain forward momentum, even if I regularly veered off course from some of those.
• Collaborate actively - My favorite part of RC were the collaborations. I was remote but I still loved the workshops and presentations, they were a great way to connect with, learn from, and get inspired by other recursers.

Should you join Recurse Center?

Maybe! I had a great time but I don't think it's for everyone.

• A big time commitment - fulltime for 6-12 weeks
• Focused on technology / learning, not building businesses
• Is largely self-directed

But I personally had a great time and think it can be fun and helpful in a lot of ways:

• If you're lost / checked out of tech and want to rediscover the fun
• Want to meet and collaborate with other tech enthusiasts
• Want to experiment deeply with tech and get inspired by others doing so

I also hear the job placement side of things is good though I don't have personal experience going through it. So if you're feeling stuck in your career / want to make a switch in tech, it could be a good option to brush up on your skills, learn new things, build resume projects, and practice for interviews with many other recursers doing similar things.

Next

So that's my return statement at the end of my 12-week programming retreat. It was fun! And while it's over it's not really over, Recursers never graduate so I'll still be going back and participating in some events - especially creative coding and presentations.

If you're interested in doing a Recurse Center batch, I highly recommend reading more on their site. They have a lot of useful info in there to help you decide if it's for you or not.

If you liked this post you might also like:

• High-Level Rust: Getting 80% of the Benefits with 20% of the Pain
• The Missing Programming Language - Why There's No S-Tier Language (Yet)
• I Built an AI Orchestrator and Ran It Overnight - Here's What Happened