FREE AI COURSE / 19 STAGES · NO LOGIN
Start with AI basics.Build the judgment to make things.
This is not a checklist of courses. It is a sequence of practice: build intuition, understand models, make a first system, then learn to make it reliable.
THE QUESTION THIS PAGE ANSWERS
ANSWER FIRSTWhat is the best way to start learning AI from scratch?
Start with what AI can do and why it fails, then move through prompts, models, and agents before RAG, evaluation, safety, and engineering. A path tied to real work builds more transferable judgment than memorizing a glossary.
Name the job you want to complete, then choose the shortest route that explains its important trade-offs.
Read “Choose the job you want AI to help with” first and use it to choose an entry point.
Do not chase every new tool at once. Establish one testable foundation before expanding the stack.
Read This Before You Build
A short orientation for choosing a useful starting point, building a study habit, and understanding why model fundamentals save time later. Read it when the AI landscape feels noisy or every tool looks equally urgent.
Learning With AI, Deliberately
A practical learning loop for using AI as a tutor without outsourcing your judgment: ask sharper questions, expose weak claims, break difficult material into pieces, and prove what you understood.
AI Without the Fog
A plain-language first pass through what AI can do, how it produces answers, why it can sound certain while being wrong, and what is safe to hand over. No math required; the goal is a dependable first instinct.
The Model Under the Product
Trace the path from training data and token prediction to chat interfaces, hallucinations, and mitigation choices. This chapter gives product decisions a technical reason instead of a trend-driven guess.
The Harness Around the Model
Learn how context, prompts, tools, retrieval, output formats, and safety checks turn a model into a working system. Treat the harness as product architecture, not as a bag of prompt tricks.
From Working Demo to Useful Product
Follow the decisions that separate an impressive demo from a dependable product: interaction loops, context budgets, memory, permissions, multi-agent collaboration, and recovery when the model loses the thread.
Engineering Patterns for Reliable Agents
Read production-oriented patterns for context assembly, tool design, evaluation, long-running work, and sandboxing. The emphasis is on boundaries you can inspect when an agent succeeds for the wrong reason.
When the Harness Improves Itself
Explore what happens when an agent can revise the scaffolding around its own work. The chapter is a guided tour of feedback loops, recursive improvement, and the controls needed before self-optimization becomes useful.
Vibe Coding, With Guardrails
Use natural-language collaboration to move faster while keeping a human-quality bar: define the brief, control the loop, document decisions, and add safety gates before generated code becomes a dependency.
Taste Engineering: Make the Output Worth Keeping
Once AI can make something usable in minutes, taste becomes the differentiator. Practice seeing hierarchy, whitespace, restraint, and consistency, then translate those judgments into instructions a model can act on.
Interaction Engineering: Make the Product Usable
Go beyond visual polish and inspect the states people actually move through: loading, empty, error, undo, confirmation, and recovery. Learn to specify interfaces as behaviors an AI can implement and test.
AI Product Psychology: Design the Feeling
AI can be slow, uncertain, and opaque even when the underlying system works. Use psychology and product signals to calibrate trust, reduce waiting anxiety, and make the experience feel honest rather than magical.
Token Cost Engineering: Make the Numbers Work
Turn an AI usage bill into design information. Read token pricing, spot tier cliffs, understand agent cost growth, and reduce waste across syntax, semantics, architecture, and output without making the product feel smaller.
Data Structures Behind AI
Build programming intuition through systems you already know: message lists, caches, indexes, queues, and graphs. The point is not memorizing definitions; it is recognizing the structures inside AI-generated code and products.
Algorithms Behind AI
Connect complexity, search, sorting, recursion, graphs, and sampling to the mechanisms behind modern AI systems. Use the connections to estimate trade-offs and review code, even when an assistant wrote the first draft.
Inside a Production Coding Agent
A source-led tour of a production coding agent: runtime, tools, memory, security, and extension points. Use the architecture as a set of questions for evaluating any coding agent you may rely on.
Inside DeepSeek Harness
Follow a plugin-based agent foundation from session logs to tool calls, compaction, inboxes, and sandboxed execution. This is an optional source-reading track for people who want to see the abstractions behind the interface.
Inside OpenAI Codex
Study how a coding agent makes context, approvals, tool execution, MCP, and sandboxing governable through its architecture. The practical takeaway is a checklist for putting security into the system itself.
Open Weights, Distillation & Local Runs
Separate open weights from open source, read licenses before deployment, and reason about distillation, hardware, and local serving. Finish with a grounded choice of what your own computer can actually run.
START HERE