From Full Stack to Agentic: Why I Learned RAG and You Should Too

I am back on the hunt for my next set of paid opportunities, and somewhere between reviewing job description after job description, I realized something important: My skills have evolved beyond those of a traditional full stack engineer. Yes, I still build web and mobile applications: primarily within the JavaScript ecosystem. But my developer toolbox has expanded in a way that has fundamentally changed how I approach problems, design systems, and ship solutions. What used to take me weeks to plan and build, I can now often ship in days. So what do we call this new discipline?

Agentic AI software development

We are officially in an era where software tasks can be executed autonomously, in parallel, orchestrated and guided by engineers rather than manually implemented step-by-step. And while that idea can feel a bit hair-raising, I won’t lie, the productivity gains have been incredible. This shift is exactly why I’ve decided to double down on building my agentic AI skillset through hands-on tutorials and projects. I started with one of the most foundational concepts in this space: RAG. 

What is Retrieval-Augmented Generation (RAG)?

Retrieval-Augmented Generation (RAG) is a framework that combines retrieval-based systems with generative models to produce more accurate, context-aware responses.

At a high level:

• You retrieve relevant information from a data source

• You augment that information with a user query

• You pass it to a model to generate a response

RAG consists of two main components:

• Retriever → Finds relevant documents

• Generator → Produces a response using those documents + the user query

This is one of the most effective ways to customize a large language model using your own data.

How RAG Works (Under the Hood)

There are a few key steps involved:

• Indexing → Documents are parsed and preprocessed

• Chunking → Large documents are broken into smaller pieces

• Embedding → Each chunk is converted into a vector representation using an embedding model

• Storage → These vectors are stored in a vector database

When a user submits a query:

• The query is embedded into a vector

• The system retrieves the most similar vectors (documents)

• Those documents are passed into the LLM to generate a response

Why This Matters

Understanding RAG allows you to transform LLMs from general-purpose tools into specialized, domain-aware assistants. It also helps:

• Improve response accuracy

• Reduce hallucinations

• Give you control over the model’s knowledge base

Who Should Learn This?

Honestly—anyone building software today.

• Software Engineers

• ML Engineers

• AI Engineers

• Prompt Engineers

• AI Architects

Whether you're building your own knowledge systems or working with enterprise data, RAG is quickly becoming a foundational skill.

My Learning Journey: From Naive to Advanced RAG Starting with Naive RAG

I began with a basic implementation using:

• Python virtual environments

• OpenAI API Key

• ChromaDB for vector storage

A few highlights:

• I ran out of API credits (classic 🫣)

• I debugged my way through the setup

• Eventually got a working Naive RAG pipeline

And it worked… but it wasn’t perfect.

Challenges with Naive RAG

• Limited contextual understanding

• Inconsistent retrieval quality

• Weak integration between retrieval and generation

• Scaling inefficiencies

• Low adaptability without manual tuning

In short: it gets the job done, but not well enough for production-level systems.

Leveling Up: Advanced RAG Techniques

To overcome these limitations, I explored more advanced techniques.

Key Improvements

Pre-Retrieval Optimization

• Better indexing strategies

• Cleaner, richer data

• Improved query structuring

Post-Retrieval Processing

• Combining retrieved data more intelligently with the query

• Refining context before generation

One Technique That Stood Out: Query Expansion

This approach enhances the original query by generating additional context or related queries. I implemented a version of this where:

• An initial (sometimes hallucinated) answer is generated

• That answer is used to refine and expand the original query

• The improved query retrieves more relevant documents

To make things more interesting, I built a visualization:

• A 2D vector space scatter plot showing how closely documents relate to

  • The original query

  • The augmented query

Watching the retrieval shift as I asked different questions was one of those “aha” moments.

Expanding Further

I then experimented with:

• Generating multiple queries using an LLM

• Feeding all queries into the vector database

• Aggregating results through another LLM to produce a final answer

Real-World Use Cases

• Intelligent Q&A systems

• Academic research tools

• Customer support automation

• Data exploration and analysis

• Healthcare information retrieval

What I’m Building Next

While working through these tutorials, I had a realization: I’ve been sitting on a nearly 200-page study guide for full stack engineering interviews. So why not turn it into something more powerful? My next project is to build:

• A Naive RAG-powered interview prep assistant (for rapid prototyping)

• Then evolve it into an Advanced RAG system with query expansion

The goal is to help others prepare for technical interviews using a system that can surface the right knowledge at the right time.

Learning RAG hasn’t just added another tool to my toolbox—it has changed how I think about building software altogether. We’re moving from writing every function manually to designing systems that think, retrieve, and generate alongside us. Agentic workflows aren’t replacing engineers; they’re amplifying us. And the engineers who learn how to design, guide, and refine these systems will be the ones shaping the next era of software development. As for me?

I’m just getting started.

See my tutorial practice repos here:

• Naive RAG Repo: https://github.com/AllisonMH/rag-intro-fcc 

• Advanced RAG Repo: https://github.com/AllisonMH/advanced-rag-intro-fcc/tree/main 

Learning Resources:

• RAG Fundamentals by Free Code Camp: https://www.youtube.com/watch?v=ea2W8IogX80&t=690s

• NVIDIA Developer Blog, Demystifying RAG: https://developer.nvidia.com/blog/rag-101-demystifying-retrieval-augmented-generation-pipelines/

• CrateDB RAG Pipelines Overview: https://cratedb.com/use-cases/ai-vector-search/chatbots/rag-pipelines

• W3 Schools Python Virtual Environment Walkthrough: https://www.w3schools.com/python/python_virtualenv.asp