If you want to get beyond “type prompt, get answer” and understand how large language models work, start with intuition, move to building, and then study the theory. That is the sequence Prayush Adhikari recommends after watching three resources: Piyush Garg’s overview, Dev Weekends’ practical sessions, and Stanford Online’s CME295 course. It is a useful map, not a proven best curriculum; the descriptions below reflect Adhikari’s account unless otherwise noted.
What this learning path is designed to teach
The three resources serve different goals rather than competing to be the single best introduction. Garg’s video is presented as a conceptual starting point; Dev Weekends’ sessions move toward building applications; and CME295 is positioned as a deeper course of study. Adhikari’s essay, published on DEV Community on September 27, 2026, recommends following them in that order. The DEV page displays “Sep 27,” while the author’s portfolio gives the year.
As an Amazon Associate I earn from qualifying purchases.
Adhikari describes the motivation as curiosity about AI beyond “type prompt, get answer.” In his words: “If you’re on the same journey — curious about AI beyond “type prompt, get answer” — I’m breaking down what I learned from each one, and honestly, I’d watch them in the same order I did.”
This is a learning route, not a claim that watching videos alone makes someone proficient. Use it to choose what to learn next, and pair explanations with hands-on work if you want to build or evaluate systems.
#1 Best Overall
How the three resources differ
| Resource | Role in the path | Focus described by Adhikari | Best fit |
|---|---|---|---|
| Piyush Garg, “How LLMs Works? – Overview” | Conceptual intuition | Tokens, embeddings, positional information, attention, next-token prediction, temperature, training and inference | Readers asking what a token is or how an LLM produces a response |
| Dev Weekends, “Level 0 and Level 1 – Gen AI Sessions” | Practical application | API message roles, streaming, structured outputs, tool calling, prompting, fine-tuning and retrieval-augmented generation | Readers who want to build software that uses language models |
| Stanford Online, “CME295: Transformers and Large Language Models I, Autumn 2025” | Deeper study | Adhikari describes a nine-lecture sequence covering transformers, model families, training, tuning, reasoning, agents, evaluation and trends | Readers seeking a more systematic study of the field |
The resource descriptions in this comparison come from Adhikari’s essay, not independent reviews of the videos or workshop. The Stanford distinction matters in particular: Stanford’s public CS336 course material is a separate course, “Language Models From Scratch (Spring 2025),” and does not verify CME295’s stated lecture count or syllabus.
Start with the mental model: tokens, context and prediction
In Adhikari’s account, Garg’s overview is the entry point for building intuition about how language models work. The concepts he says it covers form a useful chain: text is represented as tokens; those tokens are processed into contextual representations; attention helps the model relate information across the sequence; and the model predicts a subsequent token. The generated response emerges through repeated prediction.
Concepts to watch for
- Tokenization: how text is divided into the units a model processes. Adhikari says the video uses Gemma tokenization as an example.
- Embeddings and position: numerical representations and positional information help provide the model with usable input and sequence order. The essay mentions OpenAI embeddings among the examples shown.
- Self-attention and multi-head attention: mechanisms the essay says the video explains as part of how contextual information is handled.
- Next-token prediction and temperature: the model’s prediction task and a generation setting that affects the output process.
- Training versus inference: training updates model weights; inference uses a trained model to generate output. Adhikari says the video demonstrates ideas with PyTorch code and Hugging Face Transformers.
These are descriptions of the video in Adhikari’s essay; the video itself was not independently reviewed for this article. Treat the examples as signposts for topics to investigate, not as a verified inventory of every demonstration.
Free tools Windows power users keep installed
One-click scans. No signup required.
Move from concepts to building an application
Once the basic vocabulary makes sense, Adhikari’s suggested next stop is Dev Weekends’ “Level 0 and Level 1 – Gen AI Sessions.” He presents these sessions as the practical stage: learning how an application communicates with a model and how to build useful behavior around that interaction.
Application concepts in the sessions
- API message roles and prompting: how messages are structured and how prompting approaches shape an interaction.
- Streaming: delivering generated output as it arrives rather than waiting for the full response.
- Structured outputs: asking for responses in a more predictable format for downstream software.
- Tool calling: enabling a model-mediated workflow to invoke tools as part of an application.
- Fine-tuning and retrieval-augmented generation (RAG): two different approaches discussed in the essay for adapting a system to a task or supplying relevant information.
Adhikari outlines a RAG pipeline as parsing documents, splitting them into chunks, embedding and storing those chunks, retrieving relevant material for a query, and adding that material to the prompt. The retrieved context can help ground an answer in external material, but it does not eliminate hallucination risk. The essay also names RAGAS as an evaluation framework; it does not establish that any particular application or workshop result was tested.
As with the other resources, these workshop details are Adhikari’s description, not independently confirmed session contents. Use them as a checklist of application topics to look for rather than a guarantee of a specific implementation or outcome.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Use a course for more systematic study
Adhikari puts Stanford Online’s “CME295: Transformers and Large Language Models I, Autumn 2025,” taught by Afshine and Shervine Amidi, at the theory-focused end of the path. His essay describes it as a nine-lecture sequence spanning transformers, model families, training, tuning, reasoning, agents, evaluation and current trends.
Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchPC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11That exact course description and lecture count are attributable to Adhikari; the Stanford material reviewed here is a different offering, CS336: Language Models From Scratch (Spring 2025). Stanford describes CS336 as a course aimed at understanding language models through building, with lectures and assignments available online. Its materials also caution that lessons learned from small models do not necessarily transfer fully to frontier models. That makes hands-on coursework valuable for understanding mechanisms, but not a substitute for experience with frontier-scale systems.
Keep the two Stanford courses distinct when choosing what to study: the CS336 materials support the broader point that Stanford offers public, build-oriented language-model instruction, but they do not establish CME295’s syllabus.
Choose your next step by what you want to do
- You want to understand the vocabulary first: begin with the conceptual overview and pause to clarify tokens, embeddings, attention, prediction, training and inference.
- You want to make an application: move to API interactions, structured outputs, streaming and tool use, then examine whether RAG or fine-tuning suits the problem.
- You want a structured technical foundation: use a course with lectures and assignments, and remember that small-model exercises illuminate fundamentals without fully representing frontier-scale systems.
The sequence is Adhikari’s recommendation, not an established guarantee that every learner should follow the same order. A software developer may want to reach application work quickly; a reader focused on model internals may choose deeper study sooner. The practical benefit of the map is that it separates three goals—understanding, applying and studying—so you can select material that matches the question you have now.
Quick Recap
Sources
- Prayush Adhikari, “I Spent a Weekend Binge-Watching LLM Content So You Don’t Have To (Okay, You Still Should, But Here’s the Map),” DEV Community
- Prayush Adhikari’s portfolio
- Stanford CS336: Language Models From Scratch (Spring 2025), Lecture 1 materials
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Clear out junk files and repair common Windows errorsFree Scan →
