Certificate “Build AI-Powered Apps” from Code with Mosh, issued December 2025
Open in a new tab
AI

Build AI-Powered Apps

Code with MoshDecember 2025 · 7 hrs · 120 lessons
Open certificate as PDF

A project-based course by Mosh Hamedani on building LLM applications: from the fundamentals of language models (tokens, model choice, model settings) through a modern full-stack setup with Bun, TailwindCSS and shadcn/ui to two end-to-end projects — a chatbot with a streaming UI and a review summariser with MySQL, Prisma and TanStack Query. It adds a dedicated module on prompt engineering and the use of open-source models via Hugging Face and Ollama. Refactoring runs through the whole course: repository, service and controller are extracted step by step. Fully completed (all lessons).

Scope
7 hrs
Lessons
120 across 8 sections
Instructor
Mosh Hamedani
Language
English
Format
Video course with project work
Progress
100 % completed
Completed
7 December 2025

Contents & competencies

  • Language model fundamentals: what LLMs can do, understanding and counting tokens, choosing the right model, model settings and API calls
  • Modern full-stack setup: Bun, separate frontend and backend, OpenAI API key handling, TailwindCSS, shadcn/ui, Prettier and pre-commit checks with Husky
  • Chatbot backend: chat API, conversation state management, input validation and error handling — then refactored into repository, service, controller and routes
  • Chatbot frontend: chat UI, state management, markdown rendering, typing indicator, auto-scrolling and error handling, broken down into separate components
  • Prompt engineering: how a good prompt is built, supplying context, steering the output format, giving examples, reducing hallucinations and improving prompts iteratively
  • Review summariser: MySQL and Prisma with schema, migrations and realistic test data, an API to fetch and summarise reviews, storing and regenerating the summary, edge cases
  • Frontend with TanStack Query: displaying reviews and star ratings, loading skeletons, error handling, mutations and an extracted API layer
  • Open-source models: finding and calling models on Hugging Face, choosing the right model for the task, running models locally with Ollama

Syllabus

The course page states 7 hours and 120 lessons across 8 sections but lists individual lessons only for “Getting Started”. The outline here is therefore taken from the course player and shows all 109 lessons that were included at completion in December 2025 — the course has grown since. The Code with Mosh certificate itself states no scope. The numbering of sub-lessons (2.1, 4.3 …) has been removed in favour of continuous counting.

Getting Started7 min · 6 lessons
  1. Welcome
  2. Prerequisites
  3. What You'll Learn
  4. Getting Help
  5. Source Code
  6. Submitting Feedback
Introduction to AI Models32 min · 8 lessons
  1. Rise of AI Engineering
  2. What Are Large Language Models?
  3. What Can You Do With Language Models?
  4. Understanding Tokens
  5. Counting Tokens
  6. Choosing the Right Model
  7. Understanding Model Settings
  8. Calling Models
Setting Up a Modern Full-Stack Project50 min · 11 lessons
  1. Setting Up Bun
  2. Creating the Project Structure
  3. Creating the Backend
  4. Managing OpenAI API Key
  5. Creating the Frontend
  6. Connecting the Frontend and Backend
  7. Running Both Apps Together
  8. Setting Up TailwindCSS
  9. Setting Up ShadCN/UI
  10. Formatting Code With Prettier
  11. Automating Pre-Commit Checks With Husky
Building a ChatBot1 hr 15 min · 30 lessons
  1. Introduction
  2. Building the Backend
  3. Building the Chat API
  4. Testing the API
  5. Managing Conversation State
  6. Input Validation
  7. Error Handling
  8. Refactoring the Chat API
  9. Extracting Conversation Repository
  10. Extracting Chat Service
  11. Extracting Chat Controller
  12. Extracting Routes
  13. Building the Frontend
  14. Designing the Chat UI
  15. Managing State
  16. Sending Messages
  17. Displaying Messages
  18. Styling Messages
  19. Rendering Markdown Text
  20. Adding a Typing Indicator
  21. Auto-Scrolling to the Latest Message
  22. Improving Copy Behaviour
  23. Improving the Look and Feel
  24. Handling Errors
  25. Refactorings
  26. Extracting TypingIndicator Component
  27. Extracting ChatMessages Component
  28. Extracting ChatInput Component
  29. Recap
  30. Summary
Prompt Engineering32 min · 12 lessons
  1. What is Prompt Engineering
  2. Anatomy of a Good Prompt
  3. Providing Context
  4. Controlling the Output Format
  5. Providing Examples
  6. Handling Errors and Edge Cases
  7. Reducing Hallucinations
  8. Refining Prompts
  9. Improving Chatbot Responses
  10. Adding Sound Effects
  11. Exercises
  12. Summary
Building a Review Summarizer2 hrs 20 min · 32 lessons
  1. Introduction
  2. Setting Up the Database
  3. Setting Up MySQL
  4. Setting Up Prisma
  5. Defining the Prisma Schema
  6. Running Migrations
  7. Refining the Prisma Schema
  8. Populating the Database with Realistic Data
  9. Building the Backend
  10. Creating the API to Fetch Reviews
  11. Refactoring: Separation of Concerns
  12. Creating an API for Summarizing Reviews
  13. Generating Summaries
  14. Refactoring: Extracting the LLM Logic
  15. Refactoring: Extracting the Prompt
  16. Storing the Summary
  17. Handling Regeneration
  18. Handling Edge Cases
  19. Fetching the Summary
  20. Building the Frontend
  21. Displaying Reviews
  22. Displaying Star Ratings
  23. Displaying Loading Skeletons
  24. Handling Errors
  25. Introducing Tanstack Query
  26. Displaying the Summary
  27. Triggering Summary Generation
  28. Displaying Loading Skeletons
  29. Handling Errors
  30. Refactoring with Mutations
  31. Refactoring for Readability
  32. Extracting the API Layer
Building with Open Source Models28 min · 8 lessons
  1. Introduction
  2. Why Use Open-Source Models
  3. Finding Open-Source Models
  4. Calling Hugging Face Models
  5. Choosing the Right Model For the Job
  6. Running Models Locally
  7. Using Hugging Face Models with Ollama
  8. Calling Ollama Models
Course Wrap Up2 lessons
  1. Course Wrap Up
  2. Feedback

Topics

LLMOpenAI API