Skip to main content

Where to Start: Become an Agentic AI Engineer in Days, Not Months

You don't have months to learn AI. Good news: you don't need them. Everyone starts the same way — six Foundations courses in a browser, nothing installed, whether or not you can code — then makes one decision (use AI to do your work, or build AI that does it for you), and walks the courses from there. Engineer is the destination, not the prerequisite.

This section is the shortest path from beginner to shipping Agentic AI Engineer — measured in days, not semesters: productive with AI in a matter of hours, your first Digital FTE in a weekend, and the full Agent Factory stack inside a month of focused evenings.

Why Days, Not Months​

That promise sounds impossible until you see the method behind it. It is the same method anyone uses to survive a new job with little background. First, you get an overview of the work. Second, you identify the few topics that are critical to actually doing the job. Third, you learn the 80% of each topic that gets used routinely, you start working, and you pick up the rest as you go — with reference material at your elbow.

The three-step pedagogy: overview, find what matters, then cover the critical 80% and ship while picking up the rest through real use

Trying to learn every detail of every topic up front takes months. You would burn out before you shipped anything. Our pedagogy is built on the opposite philosophy: cover the critical 80%, get you working, and let the rest fill in through real use. Every crash course in this section is designed exactly that way.

note

A note on this book. The crash courses in this section get you working fast. The chapters in the book are your post-course reference — written to be returned to whenever a gap shows up in real work.

How This Is Organized (Start Here)​

You don't learn this by reading everything; you learn it by walking one clear path — so here is that path, the only map you need to hold. It is the same one the sidebar already shows you: Foundations first, then General Agents, then one of two tracks — Mode 1 or Mode 2 — and finally References & Companions. The whole thing turns on a single decision in the middle (which mode), and everything before that decision is shared by every reader.

Start by reading the thesis. It comes in two versions — one for technical and business professionals, and one for absolute beginners — so everyone can follow regardless of background. After the thesis come the Foundations: what a language model actually is, prompting, the two document languages of agentic work, commissioning code you never write, teaching AI a task once and connecting it to your apps, and learning how to think in the AI era. Every reader takes these before picking a mode.

Where do you start? In a browser. Your first six courses, the Foundations, run in a chat tab — Claude.ai, ChatGPT, or Gemini — with nothing installed, whether or not you can already code. That browser tab is where most everyday AI value already lives. When the work needs your real files, you graduate to a general agent on your own machine, and the three layers of agentic work begin.

The mental model you'll need: work in the AI era happens in three layers. You use general agents to solve problems. You build AI Workers to do specialized jobs. You assemble those Workers into AI-Native Companies. Every professional engagement starts the same way — a human directing a general agent. The only question is which agent, which depends on what you're trying to accomplish.

note

A quick naming note. Throughout this book, AI Worker, Digital FTE, and AI Employee refer to the same idea — a specialized agentic system doing a real job under human-defined policy. We use Digital FTE when emphasizing business value, AI Worker when emphasizing implementation, and AI Employee when emphasizing role inside the company. For any other unfamiliar term, the glossary is your friend.

Those same three layers are the arc this section walks you along, from where you are now to where it gets you:

The six-stage journey from Beginner to AI-Native Company Architect — Beginner, Agent User, Agent Builder, Worker Builder, Workforce Builder, then AI-Native Company Architect — the three-layer model at finer resolution

You don't have to walk the whole path. Most readers stop at stage 3 or 4, and that's enough for a serious career or a first startup. The full path is there if you want it.

Pick Your Mode​

Here is that decision up close — the fork between using AI and building AI that works for you. Make it first in the abstract, then by finding your own row.

The thesis section The Two Modes of General Agent Use describes the two ways people actually use general-purpose agents. Mode 1 if you want to use AI to do your work. Mode 2 if you want to build AI that does the work for you. The label "Manufacturing" sounds industrial, and it is — building Workers is a different discipline from using them.

One thing the decision does not change: everyone picks a general agent (Course 7 or Course 8) right after Foundations. The mode decision routes you to a track; it does not decide whether you use a general agent. You always do.

Mode 1 versus Mode 2: in Mode 1 the agent does the work; in Mode 2 the agent builds a Worker that does the work

Mode 1 — Problem-SolvingMode 2 — Manufacturing
Pick this if you...Want AI to help you do work fasterWant to build AI Workers that do work for you
Who it's forAnyone — engineers or knowledge workersEngineers (or a knowledge worker paired with an engineer)
Your toolClaude Code/OpenCode or Claude Cowork/OpenWorkClaude Code/OpenCode for building; the course pages teach concepts you read on your own first, then ask the agent to build
Start withCourse 7 (engineers) or Course 8 (knowledge workers)Course 14 — Build AI Agents
You produceCompleted workA Worker that produces work, on its own
Governed bySeven Principles of Problem SolvingSeven Invariants of the Agent Factory

A note on Mode 1. If you want to push Mode 1 further and deploy a personal AI assistant that runs your daily workflows on its own, follow OpenClaw with General Agents (Course 11) after the principles course.

A note on Mode 2. The general agent's output is not the outcome — it is the Worker that produces the outcome. A developer uses Claude Code to spec, build, and deploy a code-reviewing Worker. A finance analyst, paired with an engineer, uses Claude Code to spec a close-process Worker that runs every month-end. Same tool, same discipline, different domain.

Your Starter Path​

If the Mode picker still feels abstract, here is the same decision in fully concrete terms — pick the row that fits you and start with the leftmost course. Every path begins with the universal Foundations (Courses 1–6).

You are...Your starter pathFirst milestone
Absolute beginnerThesis → Course 1 (What AI Is) → Course 2 (Prompting) → Course 3 (Markdown & HTML) → Course 4 (Code You Never Write) → Course 5 (Skills & Connectors) → Course 6 (Thinking)Foundations laid; continue with a mode below
Knowledge workerFoundations (Courses 1–6) → Course 8 (Cowork) → Course 10 (Principles)Ship real knowledge work with AI
EngineerFoundations (Courses 1–6) → Course 7 (Claude Code) → Course 14 → Course 15 (FTE)Ship your first Digital FTE
Workforce builderThe Engineer path, then Course 17 (Paperclip) → Course 20 (Evals) → Course 21 (Deploy)A governed AI workforce, deployed to the cloud

The Courses​

You've made the call — so here is every course, grouped exactly as the sidebar shows them, with the one fastest route and the time at each depth called out before the full list.

tip

Several courses include a Reader track — a conceptual, no-build pass you take to understand and direct the work rather than implement every line. Using it where offered, the fastest path to a shipped Digital FTE is Foundations (Courses 1–6) → Course 7 → Course 14 → Course 15 → Course 20 (Reader track) — about 15 hours of focused work. The remaining courses turn that Digital FTE into a governed workforce, but you don't need them to ship your first one.

Total time by depth: Mode 1 (productive with AI) ~8h · Mode 2 minimum (first Digital FTE) ~15h · Mode 2 full (governed workforce) ~28h · Full Agent Factory mastery ~48h (with the cloud deployment course).

Everyone shares the same six Foundations below; after those, the path splits by mode.

Foundations (Everyone)​

  1. What AI Actually Is — A no-math, no-code mental model of the machine sitting under every other course: nine ideas that explain why a language model predicts rather than looks things up, why it sounds certain even when wrong, why it miscounts the letters in "strawberry," and why its skill is jagged. Read it first and every "why did it do that?" in the courses below already has an answer waiting. About 45 minutes.

  2. AI Prompting in 2026 — A 45-minute, 13-concept primer on using ChatGPT, Claude, and Gemini well in 2026: context, reasoning modes, deep research, multimodal, and AI desktop apps. The mechanics every chapter of this book assumes you already know.

  3. Markdown In, HTML Out — A 13-concept primer on the two document languages of agentic work: writing Markdown specs precise enough for a machine (headings, lists, fences, links, and the spec skeleton with its grade-to-9 validation loop), and demanding HTML output rich enough for a human, with the publishing ladder that turns an artifact into a shareable link. About 90 minutes including the closing prompts. Prereq: Course 2.

  4. Code You Never Write — A 13-concept primer on getting AI to write, run, and verify code you never read. Which tasks are code problems (Volume, Precision, Repetition, Files), how to write a five-section brief with no technical words in it, how to force computation over estimation, how to verify a result you cannot read, and the five surfaces where AI runs code for you: Claude.ai, Claude Code, OpenCode, Cowork, and OpenWork. About an hour, plus forty minutes of closing prompts and four projects. Prereq: Courses 2 and 3.

  5. Skills & Connectors — A no-code primer on the two upgrades that turn a chat box into a coworker. A Skill teaches AI a task once (a SKILL.md it loads only when your request matches) so it works your way every time; a Connector gives AI safe, permission-scoped access to your real apps — Drive, Gmail, Slack, a tracker — over the MCP standard. When to reach for each, how to use the built-in ones, how to have AI build your own (it writes the file for you), and how to do it all safely, across the same five surfaces, with notes on the ChatGPT and Gemini equivalents. Built for accountants, doctors, marketers, engineers, and students. About 75 minutes including the closing prompts and projects. Prereq: Courses 2–4.

  6. How to Think in the AI Era — The cognitive discipline that separates people who get real value from AI from those who don't: when to reach for an agent, when not to, and how to frame problems so an agent can actually help.

General Agents (Pick Your Co-Worker)​

These are the general-purpose agents you'll direct in every mode that follows. Engineers pick the coding agent; knowledge workers pick the desktop co-working agent. Both are reused in Mode 2 — they aren't Mode-1-specific, they're the tool layer beneath every mode. The third course here, Spec-Driven Development, is the discipline you run on whichever one you pick.

  1. Agentic Coding Crash Course: Claude Code and OpenCode — A 90-minute, 15-concept tour of Claude Code and OpenCode. Same vocabulary, slightly different keybindings; skills transfer cleanly between the two tools. The general-agent starting point for engineers.

  2. Cowork Crash Course — A 90-minute, 15-concept primer on Claude Cowork: delegating real desktop knowledge work, the autonomy ladder, prompt-injection defenses, and the plan-review habit that prevents most regrets. The general-agent starting point for knowledge workers.

  3. Spec-Driven Development — A 13-concept primer on agreeing what to build before you generate how it gets built: the project constitution, the four phases (Research, Specify, Clarify, Build), and the same discipline run three ways, in claude.ai, Claude Code, and OpenCode. A thinking discipline, not a coding skill, so non-programmers run it too. About 90 minutes plus a twice-built worked example and six hands-on projects. The discipline that makes whichever co-worker you picked reliable.

Mode 1 — The Problem-Solving Track​

  1. Problem Solving with General Agents — A 90-minute, 7-principle crash course in the operating discipline that turns any general agent — Claude Code, OpenCode, Cowork, or OpenWork — from a clever toy into a tool you can ship real work on. The seven principles apply across all four tools: Bash as the key, code as the universal interface, verification as a core step, small reversible decomposition, persisting state in files, constraints and safety, and observability. Includes the four-phase workflow — explore, plan, implement, commit — and a capstone exercise.

  2. OpenClaw with General Agents — A 90-minute, 6-scenario hands-on course where your general agent installs and configures a Personal AI Employee on OpenClaw: from zero to an AI Employee on your phone, with one custom skill, one MCP tool, one heartbeat task, and a closing ACP-spawn demo where the AI Employee summons a coding agent of its own. Karpathy's "little skill," expanded. Prereq: Course 7.

Mode 2 — The Manufacturing Track​

First, a gateway. Every course below assumes you can read the Python your agent writes, so if you have never coded, start with Course 12 before the build courses. From there, the manufacturing path runs end-to-end in seven moves: build the Agent, promote it to an Employee, connect Employees with a nervous system, add management, make hiring dynamic, free the founder, and prove the whole workforce is measurably trustworthy with evals. Without that last move, manufacturing is unprovable — Workers you can't measure are Workers you can't actually ship.

  1. Python in the AI Era — A read-before-you-write primer for people who have never coded. You don't write Python from a blank page; you learn to read, predict, test, and verify the Python your agent generates, using the PRIMM-AI+ method and the Test-Driven Generation (TDG) loop. 17 concepts and six small projects, with a companion base that turns your agent into a disciplined tutor. The literacy gateway every Mode 2 build course assumes, and the on-ramp to Part 4. Prereq: Course 7.

  2. Give Your AI Searchable Context: RAG on Postgres with pgvector — A 15-concept primer on giving your AI searchable context: you direct your agent to turn Neon + pgvector into a working RAG system — schema, an embedding worker, chunking, semantic and hybrid search, eval-driven retrieval, and a read-only RAG MCP server any agent can call. The retrieval foundation the Digital FTE builds on, from the same Manufacturing base. ~90-minute read plus a build. Prereq: Course 7.

  3. Build AI Agents Crash Course — A 90-minute, 16-concept primer on the OpenAI Agents SDK: agent loop, tools, sessions, streaming, handoffs, guardrails, tracing, day-1 evals, human approval, sandboxed deployment on Cloudflare, and DeepSeek V4 Flash for cost discipline. Prereq: Course 7.

  4. From Agent to Digital FTE — A 4-hour workshop on turning a basic agent into a durable Worker: portable Skills, Neon Postgres with pgvector as the system of record, the Model Context Protocol as the wire between them, audit-trail discipline, approval as the authority model, and a worked customer-support Worker built end-to-end. 15 concepts, 8 build decisions. Quick Win in 15 minutes; cheat-sheet skim in 90; full build in roughly 3 more hours. Prereq: Course 14.

  5. From Digital FTE to Production Worker with a Nervous System — A 90-minute, 15-concept course on wrapping your Digital FTE in an Inngest operational envelope: durable execution, event-driven triggers, step memoization, concurrency and throttling, replay, and HITL gates. Extends the customer-support Worker so it survives network blips, restarts, and long-pending approvals. Prereq: Course 15.

  6. Building a Workforce with Paperclip — A 90-minute, 6-scenario hands-on course where your coding agent stands up Paperclip (the open-source, MIT-licensed AI-native company control plane), hires a keyless local Worker, files a board approval as a permanent audited decision record, swaps in a real Gemini-backed Worker so a budget finally has billable work to meter, and reconstructs the whole company history with one SQL query against the activity log. Scenarios 1-4 and 6 run with no API key; only the budget scenario needs a free Gemini key. Prereq: Course 15 or Course 11.

  7. From Fixed to Dynamic Workforce — A half-day, 15-concept and 7-decision workshop where the workforce from Course 17 detects a capability gap, drafts a hire proposal, walks it through the same approval primitive that gates a $500 refund, and provisions a Legal Specialist on Claude Managed Agents. Hiring as a callable function. Closes Invariant 6 (the workforce is expandable under policy). Prereq: Course 17.

  8. From Founder Bottleneck to Owner Delegate — A half-day, 15-concept and 7-decision workshop where the owner of the workforce configures an Owner Identic AI on OpenClaw: it reads routine Paperclip approval requests, clears the ones inside a signed delegated envelope, and surfaces only the decisions that genuinely need a human. The owner is the last bottleneck — this course removes it. Closes Invariant 2 (every human needs a delegate). Ships a downloadable lab starter zip with mock endpoints, rules templates, and sample judgment context. Prereq: Course 18.

  9. Eval-Driven Development for AI Employees — The discipline that closes the manufacturing arc and wraps everything Courses 7 through 19 built. Four learning tracks — Reader (~3-4 hours, conceptual), Beginner (~1 day), Intermediate (~2 days), Advanced (~3 days for full implementation). 15 concepts plus a 7-decision lab. Teaches the nine-layer evaluation pyramid (unit, integration, output, tool-use, trace, RAG, safety, regression, production) and the four-tool stack that fills it: OpenAI Agent Evals with trace grading, DeepEval, Ragas, Phoenix. End state: a workforce where every member is measurably trustworthy, with a weekly trace-to-regression-test promotion ritual that keeps the eval suite alive over months. Reader track for leaders; Advanced track for shipping teams. Assumes either the OpenAI Agents SDK or Claude Managed Agents runtime.

  10. Deploy Your Agent Harness to the Cloud — The course that ships everything the manufacturing track built. It teaches the harness/sandbox split: the control plane (the harness that holds secrets, runs the agent loop, and keeps state) lives in a different security boundary from the execution plane (the sandbox where the agent's generated code actually runs). You deploy one complete production path: FastAPI on Azure Container Apps for the harness, Neon Postgres for durable state, Cloudflare R2 for files, a code-execution sandbox, four-surface observability, and the Course 20 eval suite wired in as a CI gate. Four learning tracks (Reader for leaders and architects; Beginner through Advanced for shipping teams), 17 concepts, and a 9-decision agent-driven lab where your coding agent reads a companion AGENTS.md and builds the harness while you direct it. Prereq: Course 20 (Decision 8 wires its eval suite). The Reader track needs no cloud accounts.

  11. Choosing Agentic Architectures — A conceptual crash course on pattern selection: five questions about your task map to one of four core patterns (sequential workflow; single agent + ReAct + tools; planning + ReAct execution; multi-agent specialist), plus reflection as an additive layer on top. The discipline is choosing by architectural fit, not by what looks impressive: each pattern is a bet about the task, and the right one is the bet whose assumptions match reality. Teaches the five-question decision tree, the two equally common failure modes (overshooting and undershooting), the runtime signals that reveal a mismatch, and how each pattern composes with your deployment topology and your eval suite. Four learning tracks (Reader ~2-3 hours conceptual; Beginner ~1 day; Intermediate ~2-3 days; Advanced ~4-5 days), a five-case decision lab, and a printable classify-this-task worksheet for design reviews. Prereq: you can already build and evaluate agents; cross-references the agent-building, operational-envelope, and eval courses.

  12. Payment-Enabled Agents: ACP, AP2, x402, and MPP — A multi-track crash course on the four protocols that let agents move money: ACP for consumer shopping, AP2 for authorization mandates, x402 for HTTP-native machine payments, and MPP for session-based settlement. The key idea: the four are layers, not rivals. You read a use case, pick one protocol per layer (discovery, authorization, commerce, settlement), and compose them as OpenAI Agents SDK code, with the tool-input guardrail that stops a payment before it happens. Four learning tracks (Reader ~2-3 hours conceptual; Beginner through Advanced for shipping teams), 19 concepts, a five-decision lab, and the three-level spend-limit discipline that keeps a runaway agent from draining a wallet. Prereq: Course 14 (the OpenAI Agents SDK); pairs with Course 16 (Inngest) and Course 21 (cloud deployment).

References & Companions​

  1. Which AI Employees Should You Use in 2026? — Five tools matched to who you are and what you need. Find your starting point in under a minute.

  2. Cheatsheets — Interactive quick-reference cards for the key tools in this book: Claude Code, the Claude collaborative workspace, and OpenClaw.

  3. Agentic Engineering Fundamentals — A 45-minute primer on the engineering discipline that underwrites everything in this section: how to design, ship, and operate agent-based systems with the same rigor you would apply to any other production software. Optional companion read for anyone going past Course 15.

The glossary is your other constant companion. Keep both open in tabs.

What You'll Have When You Finish​

When you reach the end of this section, you won't just understand the Agent Factory thesis — you'll have built against it. You'll have used general agents to ship real work. You'll have deployed at least one Digital FTE that runs without you. You'll have connected it to a nervous system, placed it inside a Paperclip-governed workforce, watched that workforce hire its own colleagues, and freed yourself from being its bottleneck through an Identic AI. You'll have wrapped the whole thing in evals you wrote yourself, so you can prove — not hope — that every Worker is trustworthy.

That's the difference between this book and every other AI course: you don't finish with notes. You finish with a working AI workforce.

And the book stays useful — the chapters are the reference you reach for whenever you get stuck.

Everything after this section refines what you've already built. Now pick your mode and start.