I opened my fast.ai course on the morning of May 23. Chapter 10, NLP module. Two days of steady progress.
Then I closed it and opened a blank project instead.
Two Days of Consuming, Then a Break
The two days before May 23 weren't wasted — fast.ai NLP module, Random Forests, real time with Chapter 10. But somewhere in between, I started doing something the course didn't ask for: refining an MVP structure beyond what any AI tool had suggested. Thinking about architecture before touching code. Planning retrieval pipelines on paper.
I was still consuming. My brain had already shifted to building.
May 23 was when those two finally aligned.
Why I Closed the Course
There's always a pull to finish the section, finish the module, finish the thing.
I ignored it.
A production-grade RAG system had been sitting in my notes for days — a Retrieval-Augmented Generation pipeline where the AI pulls from a real knowledge base instead of just generating from memory. On May 23, I decided understanding it by building it was worth more than understanding it by reading about it.
So I paused and started building.
What Actually Got Built
Stack switch first: I'd been defaulting to Flask out of habit. For a system with async retrieval and structured endpoints, FastAPI made more sense. The catch — I'd never used it.
I spent part of the morning learning routing, dependency injection, async handlers. Not comfortable. But it clicked faster than expected, and once it did, the project moved quickly.
Hybrid search is the core of how the system finds relevant information. Keyword search is fast and literal. Vector search understands meaning. Together, they return better results than either alone.
Reciprocal Rank Fusion (RRF) merges those two result sets into one ranked list. The problem it solves: if keyword search returns Document A at rank 1 and vector search returns it at rank 4, where does it land in the final list? RRF rewards documents that appear consistently across both searches — not just highly in one. Final results end up more reliable.
The retrieval pipeline ties it together: query comes in → both searches run in parallel → RRF merges and ranks → top documents pass to the language model as context. That's the full loop.
The Gap Nobody Warns You About
Tutorials teach concepts in isolation. One chapter covers embeddings. The next covers retrieval. Each idea is clean and contained.
Real projects aren't like that.
On May 23, I was debugging an integration issue while making an architectural decision about edge case handling — both at the same time, system half-working, errors I didn't fully understand yet.
That's the gap. Not beginner vs. advanced. The gap between understanding an idea and making a system actually work end-to-end.
A tutorial can teach you what RRF is. It can't teach you what it feels like to wire it into a live pipeline, watch it return wrong results, and figure out why. That's a different kind of learning — and May 23 was the first time I'd been fully inside it.
The Day After
Two things.
I documented the project publicly — writing up what I built and why. If you're building in public, documentation isn't optional. It's how you prove to yourself and others that the work was real.
Then I went back to fast.ai — Module 6, Chapter 9. Same course, but something had shifted. Concepts hit differently when you've recently tried to use them under real pressure.
That rhythm — structured course running alongside real project work — is what I want to keep going forward.
The Honest Part
I learn faster when theory and implementation are close together. Not theory first, implementation months later. Close together — same week, ideally same day.
What I still don't fully understand: how to scope a production RAG system before building it. The system works, but I couldn't confidently tell you why certain design choices beat the alternatives. That gap is still there.
What phase are you in right now — consuming or building? And if you've had a "first real build day," what broke first? Drop it below 👇
Top comments (0)