Learn Rust from Bespoke Books

In this post, I’ll show you an entirely new way to learn programming in technology domains — by coauthoring custom-made books with the same AI that you use to build your codebases.

As a life-long founder and organizer of data, AI and programming conferences and meetupsBy the Bay, I have a lot of meetups on meetup.com — a site that’s not as active as before and might go away at some point, as every site will eventually. I’d like to scrape all the meetups I hosted, with speakers, topics, abstracts and so on, and create a graph of them. I’ll store the graph in one of the new agentic databases. I’ll allow for many backends to explore, most of them built in Rust, and the graph loader and scraper will also be built in Rust. In my new job as the Head of Community at LakeSail, I help developers work with Sail, Spark ecosystem rebuilt in Rust. So I’ll use my project as a way to learn Rust. I know everything about the domain, the data, what it means — people, ideas, events I organized. I will understand everything Codex or Claude wants to do with this data, and guide it to do what I want. And after it’d done, I ask the AI to write a book about it. A proper book in PDF, highlighting the features of Rust that it brought to bear on the domains. Traits, types, references, borrow checker, everything. The transcript of my podcast follows.

Learning Rust with Custom-Made Books

Over the last few days, I have been learning Rust in a very personal way: by using AI coding agents to build software I actually care about, then asking those same agents to turn the codebase into a custom book for me to study.

This started with my work around LakeSail, the Spark ecosystem implemented in Rust for AI workloads. Rust is everywhere in the systems I am excited about right now. It is fast, native, efficient, and increasingly central to the new generation of data infrastructure.

There are many ways to learn Rust. In my case, the concepts are not completely foreign. I ran the Scale By the Bay conference for many years, and we had Rust talks as early as 2018. I have also seen many people move from Scala and other languages into Rust. Generics, modules, options, collections, and type-driven design all feel familiar enough at a conceptual level.

But Rust is Rust. The borrow checker changes how you think. The details matter. The syntax looks different, the ownership model is real, and the best way to learn it is not by reading abstract examples forever. For me, the best way is to build something concrete.

Building Something I Care About

Over the last year, AI coding tools have helped me catch up on a large amount of technical debt from my own ambitions: projects I wanted to build for years, but never had enough time to finish.

I used Claude Code heavily last year. Even in its earlier form, it was highly productive, though it required supervision. More recently, I started using Codex again, and the experience felt transformative. It works quietly, asks questions only when they matter, forms a plan, explains what it is about to do, and then keeps moving. It is capable, reasonable, and unusually good at turning a broad request into working software.

The project I chose is typical of the things I care about. I have run Bay Area AI meetups and By the Bay conferences for more than 13 years: Scale By the Bay, Data By the Bay, AI By the Bay, and related events. Over that time, we hosted hundreds of meetups and talks with many speakers, topics, tools, and connections.

Meetup.com is no longer the center of gravity for technical communities. Many groups have moved to Luma and other platforms. But the old meetup history still contains a valuable record: speakers, talks, topics, and relationships across the AI, data, and developer communities.

I always wanted to build a graph of that history.

So I asked Codex to build a scraper that retrieves the talks from Meetup.com, stores the data, deduplicates and disambiguates speakers, and loads everything into graph databases. I wanted the implementation in Rust, partly because it is the ecosystem I want to learn, and partly because many of the databases I am interested in are themselves written in Rust.

Comparing Agents and Architectures

I began with FalkorDB, a very fast in-memory graph database backed by Redis and compatible with Cypher, the graph query language that is becoming part of the GQL standard.

Codex built the scraper and the FalkorDB backend. I loaded some data and saw the system working. Then I wanted to compare how different coding agents approach the same problem, so I asked Claude Code to build a similar implementation. I ended up with two parallel tracks: one generated mostly with Codex, one mostly with Claude.

This became surprisingly useful. I could give both systems similar prompts, sometimes copied directly and sometimes phrased differently. When one hit usage limits, I could switch to the other. Once both had substantial working code, I could ask one agent to review the other agent's implementation.

For example, I could ask Codex to inspect Claude's version and explain the architectural advantages without changing anything yet. It would notice that Claude had used traits to separate different backends, then propose how to bring a similar structure into the Codex implementation. The agents were not just writing code. They were comparing architectures.

After FalkorDB, I explored HelixDB and SurrealDB. Helix is a modern graph database with a unified language for SQL, vector, and graph workloads. It is written in Rust and exposes both HTTP and Rust SDK access. SurrealDB is another modern multi-model database, also written in Rust, and similarly interesting for graph-like and multimodal data.

For Helix and SurrealDB, I asked both Codex and Claude to implement HTTP access and Rust SDK access, then make the backend selectable from the command line. Over a few days, both systems worked through the project, and the implementations became increasingly real.

The repositories are on GitHub under my handle, alexy, as meetup-graph-codex and meetup-graph-claude.

The Book as the Learning Interface

The most interesting part came after the code was working.

I asked Codex to write me a book for learning Rust based on its codebase. I wanted examples drawn directly from the repository. I wanted explanations of the constructs, patterns, and design decisions in code that mattered to me.

At first, I asked it to focus on the borrow checker, and it produced a roughly 30-page book centered on ownership and borrowing in the project. Then I asked Claude to write a learning Rust book based on its version of the implementation. Claude produced a much larger book covering architecture, modules, traits, patterns, design decisions, and Rust features across the codebase.

Then I went back to Codex and asked it to produce a second edition with more Rust examples, more language constructs, and more architectural explanation. The resulting books live in the docs directories of those repositories.

This is a very different way to learn.

Instead of studying Rust through generic examples about movies, books, or toy databases, I am studying Rust through a system that is personally meaningful to me. These are my meetups, my speakers, my conference history, and my community graph. I know the domain. I know what the software should do. I care whether it works.

That makes the book more valuable. It is not just explaining Rust. It is explaining Rust through an implementation I want to understand.

Personalized, AI-Supported Learning

I think this is a new frontier for learning: personalized, AI-supported study around projects that matter to the learner.

The key is specificity. The project is concrete. The examples come from real code. The explanations are tied to actual design choices. The learner has enough domain knowledge to evaluate what is happening and enough curiosity to keep going.

I do not think the best version of this is always interactive. Interactivity can be useful, but it can also fragment attention. I am a believer in focus, quiet, and deep reading. Sometimes the right thing is not another chat window. Sometimes the right thing is a book.

Read it slowly. Take it outside. Read it by a lake, on a deck in Tahoe, on a mountain, on a beach, or in a redwood grove. Let the material settle. A custom book gives structure to the learning process in a way that a sequence of prompts often does not.

The Toolchain Matters Too

The process also taught me something about modern technical publishing.

When I first asked for a book, the agent told me it did not have Pandoc, Typst, or LaTeX available. That was how I learned about Typst, a modern typesetting system that feels like a more approachable way to produce precise, beautiful documents from lightweight markup.

Now I ask Codex and Claude to generate books with Pandoc and Typst. The result is a syntax-highlighted PDF with Rust code examples, good structure, and enough polish to read seriously. I have an old, small, lightweight iPad that no longer runs the newest apps, but it is still a wonderful PDF reader. It turns out to be perfect for reading these custom programming books.

Books Are Back

I am now applying the same method to other projects.

For example, I am working on Open Semantic Interchange for the semantic layer, bringing together ideas from data science, European open scientific data exchange, CODATA, DID, ODRL, semantic reasoning, metrics layers, catalogs, and open lineage. I can ask Codex to read documents, URLs, proposals, and standards, then produce a book, review, or proposal that synthesizes the material.

This starts to look like deep research, but without needing a separate app for every step. Modern agents can gather context, reason across sources, write a structured document, and produce something worth reading. The important part is what happens next: you slow down and read it.

Books give you a pause. They give you structure. They turn scattered context into something you can hold in your head.

For learning Rust, that has been extremely effective. I can build a real project, compare implementations from different agents, ask for architectural explanations, and then read a custom book grounded in code I actually care about.

That is a better way to learn than generic examples. It is personal, concrete, and serious. And it makes me think that books are back.