Craft with AI  ·  interactive course  ·  42 lessons

Build enterprise-grade AI
from scratch.

42 lessons across 7 modules — Python to LLMOps — taught the way modern engineers actually work: alongside an AI assistant, with code you run in your browser. One command opens the whole course.

42
lessons
7
progressive modules
16h 25m
guided content
1
command to start
course_runner.py · one file
# the entire course, one command
$ ./start_linux.sh
  ✓ python 3.10+ detected
  ✓ virtualenv ready      .venv
  ✓ dependencies installed
  ✓ integrity check       license · 42 lessons
  → serving course        http://127.0.0.1:8765

# your browser opens to a live, editable,
# runnable syllabus — progress auto-saved.
The course is a single Python file. You run it, a browser UI opens on localhost, and every lesson is an editable, runnable script.
  • Python 3.10+
  • FastAPI
  • Pydantic v2
  • Docker
  • ChromaDB
  • OpenAI · Anthropic · Gemini
  • GitHub Actions
  • Pandas

Curriculum

Seven modules,
beginner to production.

The modules assume zero prior knowledge — lesson one is “Hello, World!” — and end on zero-downtime cloud deployment. Each lesson is a runnable Python file with a difficulty, a stated goal, and a “Why this matters for AI” section.

01

Python Programming

19 lessons · 8h 10m

Variables, data types, operators, strings, control flow, loops, lists, dictionaries, tuples, sets, functions, modules & packages — then real APIs, pandas data analysis, and a practical mini-project to close it out.

You build

A weather-data tool from a live API, and a pandas/matplotlib study that plots real dependencies.

02

Dev Workspace

5 lessons · 1h 40m

The toolchain layer most bootcamps skip: the Linux shell, file paths and permissions, Git local & remote with merge-conflict rescue, virtual environments, and packaging a codebase for LLM context.

You build

A codebase packager that shrinks a repository into an AI-ready context prompt.

03

APIs & FastAPI

4 lessons · 1h 30m

The HTTP protocol, Pydantic validation, async/await concurrency, and FastAPI routers with auto-generated docs — the same stack production backends use.

You build

A FastAPI backend with validation, CORS, and live /docs.

04

Containerization & Docker

4 lessons · 1h 25m

“Works on my machine” solved for good: containers vs VMs, writing efficient Dockerfiles, the Docker CLI, and multi-service orchestration with Compose.

You build

A Dockerfile auditor, and a Compose stack wiring FastAPI to a vector database.

05

The AI Stack

4 lessons · 1h 30m

Resilient LLM API clients with retry and backoff, structured JSON outputs with a self-correction loop, chunking & embeddings, and vector search in ChromaDB.

You build

A working RAG retriever: documents in, top-K semantically-relevant hits out.

06

Autonomous Systems

3 lessons · 1h 05m

Agents without the framework bloat: LLM tool calling, the ReAct loop (Thought → Action → Observation), and stateful memory management.

You build

A ReAct loop engine from scratch, plus a stateful agent scratchpad.

07

Observability & LLMOps

3 lessons · 1h 05m

The last mile: tracing and telemetry for LLM pipelines, CI/CD quality gates with GitHub Actions, and cloud deployment with zero-downtime releases.

You build

A JSON pipeline tracer, a CI audit parser, and a rolling-update simulator.

Method

Not another
text-heavy bootcamp.

The course is engineered around how building software actually works today — and around how people actually learn. Three decisions carry it.

Run every lesson, in the browser

Every lesson is a real, runnable Python script — there is no separate course database. Each code block gets a “Try it here” panel with a 4-second sandboxed runner, spotlight search, day/night mode, and progress that auto-saves.

Built to build with AI

A dedicated workspace module teaches codebase packaging, token bloat, and merge-conflict rescue — the skills that make Cursor, Copilot, and Gemini genuinely useful instead of occasionally wrong.

Why this matters for AI

Every lesson opens with why. Real-world analogies, “In simple words” recaps, and “Before you run it” notes turn syntax into mental models you can reuse when orchestrating whole systems.

Portfolio

What you walk away
having built.

No toy exercises. Across 42 lessons you assemble a small portfolio of working tools — it starts as plumbing, ends as a deployable AI system.

  • Weather-data tool from a live API
  • Codebase packager for LLM context
  • Validated FastAPI backend
  • Dockerfile auditor
  • FastAPI + vector-DB Compose stack
  • Resilient LLM client with backoff
  • RAG retriever over ChromaDB
  • ReAct loop engine from scratch
  • Stateful agent scratchpad
  • LLM pipeline tracer
  • CI/CD audit parser
  • Zero-downtime rolling-update simulator

On the record

Denoted, not
marketed.

Everything below is measured from the actual lesson files — no inflated “60-hour course” claims.

Guided content
Sum of every lesson's estimated time — 985 minutes. The UI renders it live as 16h 25m.
985 min
Step sections
Every theory, exercise, warning and takeaway across the whole course, marked with a # === header in the source.
464
Exercise prompts
Hands-on tasks with solution stubs, appended to all 41 post-intro lessons.
248
Difficulty ladder
Lessons are individually graded Beginner → Advanced, so the ramp stays comfortable instead of cliff-like.
5 levels
Runtime
Course, API server, and browser UI all run on Python's standard library — a single-file server on 127.0.0.1.
std-lib only
Integrity check
On launch the runner verifies the license and author headers are intact before serving a single lesson.
gated

Start here

One command.
You're in.

No account, no hosted platform, no install of heavyweight tools. Python 3.8+ is the only prerequisite on any machine.

Linux / macOS
# one script sets up venv, deps, and opens the course
$ git clone https://github.com/prawinin/craft-with-ai.git
$ cd craft-with-ai
$ chmod +x start_linux.sh
$ ./start_linux.sh

# Windows: double-click start_windows.bat

curl → http://127.0.0.1:8765  # your browser, already there
  1. STEP 01

    Clone the repo

    Dev-workspace skills start before the first lesson — you use Git and the shell the whole way through.

  2. STEP 02

    Run one launcher

    The start script creates a virtualenv, installs only the handful of real deps, and verifies course integrity.

  3. STEP 03

    Open your browser

    The course opens on localhost with search, day/night mode, and progress tracking from the first lesson forward.

Craft with AI · free to learn

You're one
command away.

42 lessons will not make a course for you. Reading them with the code running in front of you might just make an AI engineer.