Large language models (LLMs) have transformed AI development, but turning theory into working systems requires more than just API calls or reading research papers. Ed Donner’s llm_engineering repository is a rare find: an 8-week, hands-on curriculum that walks you through the stages of LLM engineering, from running local models to building autonomous Agentic AI systems. It’s a practical scaffolded journey that lets you learn by doing, with an eye on keeping API costs manageable.
What the llm_engineering repository offers
This repo is the companion codebase for Ed Donner’s Udemy course on LLM Engineering. It’s organized as a series of weekly folders, each containing Jupyter notebooks that progressively build up concepts and practical skills. Starting with local experimentation using Ollama’s Llama 3.2 model, it moves through integrating frontier APIs like OpenAI and Anthropic, tapping into Google Colab for GPU acceleration, and culminating in Week 8 with constructing a fully autonomous Agentic AI system.
The core tech stack is Python within Jupyter notebooks, chosen for interactive learning and experimentation. The repo leverages local model inference via Ollama alongside popular cloud APIs, reflecting real-world LLM workflows that combine on-prem models and cloud services.
Under the hood, the course showcases engineering patterns like retrieval-augmented generation (RAG), multimodal orchestration, and tool calling — all central to modern LLM applications. Each weekly folder acts as a milestone, introducing new concepts and integrating them with prior work, so you’re not just running isolated scripts but building a layered system.
Why this repository stands out in practical LLM engineering education
The standout feature is its progressive, scaffolded learning path. Instead of dumping a monolithic codebase, the repo guides you step-by-step, embedding challenges in each notebook to push you to modify, explore, and extend the examples. This active learning approach is key in a field where hands-on experimentation beats passive reading.
The repo’s design reflects real LLM engineering tradeoffs. For instance, it balances local model experimentation (offline, low cost) against frontier API integration (powerful but billed per call). The course is transparent about API costs, aiming to keep total spend under $2-10 for the entire journey — a practical detail often missing in other LLM tutorials.
The code is surprisingly clean and focused on teaching rather than production robustness, which is expected in a learning repo. It’s opinionated on tooling choices like Ollama for local runs and Google Colab for accessible GPUs, making it approachable without heavy infrastructure.
One limitation is the reliance on Jupyter notebooks. While great for interactive learning and visualization, notebooks can be challenging to scale or integrate into production pipelines. Learners looking to ship LLM-based products will want to translate these notebooks into modular scripts or services. Still, the repo serves as a solid foundation.
Explore the project
The repo’s root README and weekly folders provide a clear roadmap. Start by reviewing the README for setup instructions applicable to all platforms. There’s an emphasis on bulletproof setup guides to minimize friction.
Setup instructions cover local Ollama projects, API key configurations, and Google Colab usage. The repo also includes a free alternative guide for users who want to avoid paid API calls.
The folder structure is intuitive: each week’s folder contains Jupyter notebooks that you can run in sequence. They come with embedded challenges and explanations to test your understanding.
Here’s the relevant excerpt from the README for setup and API cost guidance:
## Before the Setup instructions - a special note
Early on in the course (on Day 2), I give a demo of a very cool, popular product called Claude Code. It's an AI coding tool, similar to Cursor that we use on the course. I'm only showing this as an example of Agentic AI in action; it's not a tool that's covered explicitly on this course, particularly as we're in Cursor. But if you want to use Claude Code yourself, the Quick Start guide from Anthropic is here.
## OK - now on to Setup instructions
After we do the Ollama quick project, and after I introduce myself and the course, we get to work with the full environment setup.
Hopefully I've done a decent job of making these guides bulletproof - but please contact me right away if you hit roadblocks:
Setup instructions: Setup Instructions All Platforms
### An important point on API costs (which are optional! No need to spend if you don't wish)
During the course, I'll suggest you try out the leading models at the forefront of progress, known as the Frontier models. I'll also suggest you run open-source models using Google Colab. These services have some charges, but I'll keep cost minimal - like, a few cents at a time. And I'll provide alternatives if you'd prefer not to use them.
Please do monitor your API usage to ensure you're comfortable with spend; I've included links below. There's no need to spend anything more than a couple of dollars for the entire course. Some AI providers such as OpenAI require a minimum credit like $5 or local equivalent; we should only spend a fraction of it, and you'll have plenty of opportunity to put it to good use in your own projects. During Week 7 you have an option to spend a bit more if you're enjoying the process - I spend about $10 myself and the results make me very happy indeed! But it's not necessary in the least; the important part is that you focus on learning.
### Free alternative to Paid APIs
See Guide 9 in the guides directory for the detailed approach with ex
Verdict
Ed Donner’s llm_engineering repo is a solid resource for anyone wanting a hands-on, progressive path into LLM engineering without heavy infrastructure demands. Its stepwise approach mirrors real-world practices and gradually introduces complexity, culminating in an autonomous Agentic AI system.
It’s particularly well-suited for learners comfortable with Jupyter notebooks and Python, who want to explore both local model inference and frontier APIs under a tight budget. The embedded challenges and clear setup guides enhance the developer experience.
Limitations include its focus on educational clarity over production readiness and the notebook format itself, which may require adaptation for larger projects. Still, as a practical learning scaffold, it’s worth your time if you want to move beyond theory and build working LLM systems from the ground up.
→ GitHub Repo: ed-donner/llm_engineering ⭐ 6,161 · Jupyter Notebook