Build AI-Powered Apps – An AI Course for Developers

7h 3m 31s
English
Paid

AI is everywhere - but can you really create applications with it? Most developers have tried ChatGPT. Some have even inserted pieces of generated code into a project. But that's not quite the same as creating real AI-based features that make applications smarter, more convenient, and more valuable for users.

This is exactly what this course is dedicated to.

In "Creating Applications with AI", you will step by step understand key concepts, modern tools, and best practices for developing fully-fledged applications with AI support.

Why Every Developer Needs This Course Right Now

Practical Focus

You will learn:

  • How large language models (LLMs) work;
  • What tokens, context windows, and model parameters are;
  • How to write effective prompts using prompt engineering techniques;
  • How to build a chatbot from scratch with a clean and maintainable architecture;
  • How to create a tool for summarizing reviews that helps users make decisions faster;
  • How to integrate open-source models via Hugging Face and Ollama;
  • How to run models locally on your machine;
  • How to apply principles of clean code and best development practices;
  • How to use modern tools (Bun, Tailwind CSS, shadcn/ui, Prisma, and others) to create AI-powered full-stack applications.

Learning Through Practice

What You Will Create

  • Chatbot: An assistant for an amusement park, answering questions like "What rides are suitable for children under 10?", "Where can I find vegetarian dishes?" or "What time does the park open?". You will step by step implement the backend, organize the code according to principles of clean architecture, and create a modern frontend for convenient interaction.
  • Reviews Summarizer: A tool that turns dozens of user reviews into clear and useful insights. These same techniques can be applied to many other functions with AI integration.

About the Author: codewithmosh (Mosh Hamedani)

codewithmosh (Mosh Hamedani) thumbnail
Hi! I am Mosh Hamedani! I am a passionate and pragmatic software engineer with 20 years of professional experience and I've taught over 10 million people how to code or how to become professional software engineers through my YouTube channel and online courses. I have a Bachelor of Science in Software Engineering and a Master of Science in Networks Systems. My mission is to make coding and software engineering accessible to everyone through courses that are simple to digest, and practical to implement.

Watch Online 105 lessons

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 105 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: 1- Welcome
All Course Lessons (105)
#Lesson TitleDurationAccess
1
1- Welcome Demo
01:27
2
2- Prerequisites
00:56
3
3- What You'll Learn
03:55
4
4- Setting Up Your Development Environment
00:57
5
1- Introduction
00:37
6
2- Rise of AI Engineering
04:02
7
3- What are Large Language Models?
04:23
8
4- What Can You Do With Language Models?
02:26
9
5- Understanding Tokens and Context Window
03:03
10
6 - Counting Tokens
03:44
11
7- Choosing the Right Model
05:03
12
8- Understanding Model Settings
08:47
13
9- Calling Models
07:36
14
1- Introduction
01:13
15
2- Setting Up Bun
01:32
16
3- Creating the Project Structure
02:49
17
4- Creating the Backend
06:39
18
5- Managing OpenAI API Key
05:16
19
6- Creating the Frontend
02:46
20
7- Connecting the Frontend and Backend
05:14
21
8- Running Both Apps Together
03:24
22
9- Setting Up TailwindCSS
03:35
23
10- Setting Up Shadcn
06:31
24
11- Formatting Code with Prettier
05:03
25
12- Automating Pre-Commit Checks with Husky
06:51
26
1- Introduction
00:30
27
2- Building the Backend
00:37
28
2.1- Building the Chat API
06:27
29
2.2- Testing the API
01:58
30
2.3- Managing Conversation State
06:23
31
2.4- Input Validation
05:49
32
2.5- Error Handling
02:19
33
3- Refactoring the Chat API
02:09
34
3.1- Extracting Conversation Repository
05:21
35
3.2- Extracting Chat Service
06:45
36
3.3- Extracting Chat Controller
03:59
37
3.4- Extractring Routes
04:52
38
4- Building the Frontend
00:20
39
4.1- Building the ChatBot Component
07:29
40
4.2- Handling Form Submission
09:24
41
4.3- Calling the Backend
03:19
42
4.4- Rendering the Messages
04:38
43
4.5- Styling Messages
04:36
44
4.6- Rendering Markdown Text
02:31
45
4.7- Adding a Typing Indicator
04:10
46
4.8- Auto-Scrolling to the Latest Message
02:21
47
4.9- Improving Copy Behaviour
04:48
48
4.10- Improving the Look and Feel
08:05
49
4.11- Handling Errors
03:29
50
5- Refactorings
01:29
51
5.1- Extracting TypingIndicator Component
03:50
52
5.2- Extracting ChatMessages Component
05:20
53
5.3- Extracing ChatInput Component
08:29
54
5.4- Recap
02:37
55
1- What is Prompt Engineering
02:13
56
2- Anatomy of a Good Prompt
02:27
57
3- Providing Context
04:04
58
4- Controlling the Output Format
02:33
59
5- Providing Examples
02:45
60
6- Handling Errors and Edge Cases
01:56
61
7- Reducing Hallucinations
03:36
62
8- Refining Prompts
04:07
63
9- Improving Chatbot Responses
06:01
64
10- Adding Sound Effects
02:39
65
1- Introduction
00:51
66
2- Setting Up the Database
00:27
67
2.1- Setting Up MySQL
02:23
68
2.2- Setting Up Prisma
02:47
69
2.3- Defining the Prisma Schema
07:39
70
2.4- Running Migrations
06:02
71
2.5- Refining the Prisma Schema
03:14
72
2.6- Populating the Database with Realistic Data
03:29
73
3- Building the Backend
00:21
74
3.1- Creating the API to Fetch Reviews
07:54
75
3.2- Refactoring- Separation of Concerns
07:39
76
3.3- Creating an API for Summarizing Reviews
05:28
77
3.4- Generating Summaries
03:01
78
3.5- Refactoring- Extracting the LLM Logic
08:50
79
3.6- Refactoring- Extracting the Prompt
01:50
80
3.7- Storing the Summary
07:25
81
3.8- Handling Regeneration
02:48
82
3.9- Handling Edge Cases
06:33
83
3.10- Fetching the Summary
08:14
84
4- Building the Frontend
00:21
85
4.1- Displaying Reviews
06:36
86
4.2- Displaying Star Ratings
04:53
87
4.3- Displaying Loading Skeletons
04:39
88
4.4- Handling Errors
02:31
89
4.5- Introducing Tanstack Query
07:35
90
4.6- Displaying the Summary
02:43
91
4.7- Triggering Summary Generation
04:19
92
4.8- Displaying Loading Skeletons
04:18
93
4.9- Handling Errors
02:51
94
4.10- Refactoring with Mutations
04:24
95
4.11- Refactoring for Readability
02:45
96
4.12- Extracting the API Layer
05:29
97
1- Introduction
00:23
98
2- Why Use Open-Source Models
01:49
99
3- Finding Open-Source Models
04:18
100
4- Calling Hugging Face Models
05:36
101
5- Choosing the Right Model For the Job
06:44
102
6- Running Models Locally
03:14
103
7- Using Hugging Face Models with Ollama
02:30
104
8- Calling Ollama Models
03:04
105
1- Course Wrap Up
01:20
Unlock unlimited learning

Get instant access to all 104 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

Books

Read Book Build AI-Powered Apps – An AI Course for Developers

#Title
11.5- Source Code
21.6- Questions and Support
31.7- Connect with Me
42.2- Introduction to AI Models
53.13- Setting Up a Full-Stack Project
64.6- Building a Chatbot
75.11 - Prompt Engineering Exercises
85.12 - Prompt Engineering