I spent this morning building a working vector database session in Google Colab. Not reading about it. Not watching tutorials. Actually doing it: storing real text chunks, computing embeddings, running similarity searches, visualizing the vectors in 2D space, and calculating cosine similarity by hand. Every step mapped to what was happening conceptually. That's when it clicked: semantic similarity is just geometry. Meaning becomes direction in vector space. Closeness in meaning is literally closeness in that space.
This is how I learn now. Build first, understand as you go, then build better.
Why Concepts Beat Syntax
I have a computer science degree. Learned the formal stuff, passed the exams, understood the theory. But none of that actually unlocked building AI systems. What did was going deep on the concepts, not memorizing syntax or writing every line myself, but actually grasping why things work the way they do.
Understanding that RAG isn't magic. It's chunking strategies, embedding models, vector databases, and retrieval. Understanding that embeddings aren't just black boxes; they're high-dimensional representations where semantic similarity becomes geometric distance. Understanding that cosine similarity isn't just a formula, it's measuring the angle between vectors to find meaning.
When you understand the concepts, you can turn ideas into reality. When you only know syntax, you can copy and paste.
RAG From the Inside Out
I've been going deep on how RAG actually works. Not just the high-level pipeline (crawl, chunk, embed, store, retrieve) but the mechanics underneath. How do chunking strategies preserve meaning across boundaries? How do embedding models turn text into vectors? What do those 1,536 dimensions actually represent? Why does cosine similarity work for measuring meaning?
The breakthrough was building it step by step. Today's Colab session started with raw text, chunked it manually, sent chunks to an embedding model, stored the resulting vectors in a simple Python dictionary, then queried it with a question. Computed cosine similarity myself. Plotted the embeddings in 2D using PCA to see the clusters.
That's when semantic search stopped being abstract. I could see the geometry. Similar chunks clustered together. Outliers sat alone. The query vector landed closest to relevant chunks. It's just math, but math that captures meaning.
Agents as Collaborators, Not Crutches
Here's what I've figured out about working with AI agents: they're coding collaborators, not replacements. The understanding is mine. The agent helps with implementation.
I direct, it writes. I review, it refines. I understand what it produced and why it works. That's the skill now, not writing every line manually, but understanding what gets written and steering it toward the right solution.
Einstein said "Never memorize something you can look up." Same logic applies here. Why write boilerplate when you can direct an agent to write it and spend your energy understanding what it produced? We're past the era where writing every line manually makes you a better developer.
What makes you better is understanding deeply, building constantly, and learning from what breaks.
The Learning Stack
I'm currently working through the Anthropic Academy 96-lesson Claude Code course. It's closing the gap between understanding concepts and implementing them fluently. Most of my structured learning time goes there.
But the real learning happens when I'm building. Working with Apify actors. Running experiments in Colab. Setting up local RAG pipelines with Qdrant and Chroma. Each project teaches me something the courses can't: how things break, where the edge cases hide, why the simple approach doesn't always work.
The goal isn't to become an expert before touching the keyboard. It's to build constantly and understand deeply as you go. That loop (idea, build, understand, iterate) is the whole thing.
Building on Real Platforms
Theory is one thing. Production is another. I'm building on Apify because it forces me to think about real constraints: compute limits, billing models, error handling, actual users. My RAG content chunker isn't just a proof of concept. It's a live actor that other people use.
Working within those constraints teaches you things you can't learn in a sandbox. How to make trade-offs. How to handle edge cases. How to build something that works not just in your environment, but in the wild.
I'm expanding into local pipelines now, building RAG systems that run entirely on your machine, no API calls required. Different constraints, same principle: make it work for real use cases, not just demos.
What I'm Currently Working Through
- DeepLearning.AI LangChain Course: DeepLearning.AI LangChain course by Andrew Ng and the creator of LangChain. About 1 hour, free. A clean starting point.
- IBM Generative AI Engineering Certificate: IBM Generative AI Engineering with LLMs. Covers LangChain, RAG, Hugging Face, and LLM deployment end to end.
- Google Professional ML Engineer Certification: Google Professional ML Engineer Certification. $200 exam, cloud-agnostic, tests whether you actually know your stuff.
- Anthropic Academy: Anthropic Academy. Where most of my structured learning time is going right now. Free, directly from Anthropic.
- Apify: Apify. Where my RAG pipeline and agent skills live. The platform that made real deployment click for me.