The Capstone: Choosing the Right Technique
Twenty-one parts have built real embeddings, vector databases, RAG systems, fine-tuning judgment, and safe agents. This capstone brings every technique together into one, real, complete decision framework — the honest synthesis this entire series has been building toward.
The real, complete decision flowchart
1. Can better prompting alone solve this? (AI Fundamentals series)
→ Try this FIRST, always. If yes, done — this is the cheapest,
simplest real answer.
2. Does the answer depend on specific, real, current, or
business-specific KNOWLEDGE the base model doesn't have?
→ Yes: use RAG (parts 1-16 of this series)
→ No: skip to step 4
3. How much real knowledge, and how often does it change?
→ Small, static (Bright Leaf Coffee's FAQ): Chroma (part 4)
→ Large, growing, or requiring real access control (GreenDesk's
knowledge base): Chroma or Pinecone with metadata filtering
(parts 4, 15)
4. Does the task need the model to consistently BEHAVE a specific
way that prompting genuinely, measurably fails to achieve?
→ Yes, with a real, measured compliance gap (part 10's
evaluation): consider fine-tuning (parts 9-10)
→ No: prompting alone is sufficient
5. Does the task require taking real, independent ACTIONS — not
just answering questions?
→ Yes: build an agent (parts 17-18), with real guardrails
matched to the action's actual consequences
→ No: a chatbot or RAG system (parts 6, 13-15) is sufficientApplying it to every real project across this site's three AI series
Bright Leaf Coffee's support chatbot (AI Fundamentals, AI Projects):
RAG, small scale, Chroma — no fine-tuning or agent needed
GreenDesk's lead qualification API (AI Projects): better prompting
alone — a real, structured decision task, not a knowledge or
behavior-consistency problem
GreenDesk's email formatting (this series, parts 8-10): a genuine,
real fine-tuning candidate — IF the measured compliance gap
actually justifies it
GreenDesk's cancel/refund workflow (this series, parts 17-18): a
real, guardrailed agent — genuinely requires independent action,
not just an answer
GreenDesk's internal knowledge base (this series, parts 15-16): RAG
at larger scale, with real access control and re-indexingEvery real project across this site's entire AI curriculum — from the AI Fundamentals series' first chatbot through this series' guardrailed agent — maps cleanly onto this one flowchart. That's not a coincidence; it's the real, honest point of building the framework last, once every technique it references has already been built and understood concretely, not abstractly.
The four techniques, side by side
Prompting alone RAG Fine-tuning Agents
Solves Reasoning, Answers needing Consistent Tasks needing
formatting, specific/current/ behavior independent
structured private knowledge prompting can't action, not
decisions reliably achieve just an answer
Setup cost Lowest — Medium — vector High — labeled Medium-high —
no infra DB, embeddings data, training tools, guardrails
runs
Update cost N/A Low — re-index High — retrain N/A (depends on
when knowledge the changed doc or fine-tune technique it wraps)
changes again
Failure mode if Inconsistent Irrelevant Stale baked-in Unbounded cost/
misapplied output on real retrieved knowledge, scope from an
behavior-control context, wasted inconsistent unneeded loop
tasks latency training data
GreenDesk Lead Internal knowledge Email tone/ Cancel/refund
example qualification base (parts 15-16) format workflow
API (parts 8-10) (parts 17-18)Reading this by row instead of column is usually more useful in the moment: if the actual problem is "the model doesn't know something," that row points straight at RAG regardless of what the other three columns say about it.
The real, three-series arc, complete
AI Fundamentals: what AI, ML, and LLMs actually are — the real
conceptual foundation
AI Projects with Python: ten real, working applications — chatbots,
summarizers, translators, built and shipped
LLM & Advanced AI (this series): embeddings, RAG, fine-tuning, and
agents — the real, deeper techniques for when a project's actual
scale or requirements exceed what the first two series coveredThis capstone closes that real, complete arc — from understanding how a language model generates a single token, through building a working chatbot, through the genuine, advanced techniques (RAG, fine-tuning, agents) that make an AI feature production-ready at real scale.
A real, final, honest principle to carry forward
The most sophisticated real technique is rarely the correct default
— the correct technique is whichever one is genuinely, specifically
matched to the actual problem, at the lowest real cost and
complexity that solves it correctlyThis is the same, real, calibrated judgment running through all three of this site's AI series — not "use the most advanced tool available," but "understand precisely what each real tool does, and choose deliberately." That's the actual, durable skill this entire curriculum has been teaching.
FAQ
Can more than one technique apply to the same feature? Yes, and it's common — GreenDesk's cancel/refund workflow is an agent, but the agent itself might use RAG to look up a specific customer's order history before deciding what action to take. The flowchart picks the primary technique for a given capability, not an exclusive one.
What if a task fails step 1 (better prompting) but doesn't clearly need RAG, fine-tuning, or an agent either? That's usually a sign the task needs to be broken down further — a single feature request that doesn't fit any of the four cleanly is often actually two or three smaller ones that each fit individually.
Is RAG always cheaper to maintain than fine-tuning? For knowledge that changes, yes — re-indexing a document is far cheaper than retraining. For a fixed, permanent style or behavior that never needs updating, fine-tuning's higher setup cost can be a one-time expense rather than an ongoing one, which changes the comparison.
Do I need to fully build out one technique before knowing it's wrong? No — the flowchart's early steps (does this need external knowledge, does this need consistent behavior, does this need real action) are meant to be answered before writing code, from the nature of the task itself, not discovered by trial and error after building the wrong thing.
That's the complete LLM & Advanced AI series — and with it, the complete arc from AI Fundamentals through AI Projects with Python to real, production-grade embeddings, RAG, fine-tuning, and agents. Every technique here connects directly back to a real, concrete business need at Bright Leaf Coffee or GreenDesk — the same throughline this entire site has followed from its very first tutorial series.