Agentic Research
Developers / Engineers

Developer Track

How do I build an agent and ship it

From your first LLM API call to building your own multi-agent framework and evaluation harness. Code, architecture diagrams, and numbers we measured ourselves.

Readable lessons
123lessons
In progress
0lessons
Est. hours
24.5hours
Stages
4
Progress is stored in your browser — no signupExternal open-source course guide
Your progress
0/123
Saved in your browser only

After this stage you can:You know the vocabulary, what it can do, and have run it once

  1. 01
    Before You Start: You Only Need to Know These 20 Terms

    You can get started with AI Agents without writing code — as long as you understand what the docs are saying. This article splits the 20 terms that actually block beginners into four groups, gives a one-sentence definition for each plus which to read first, and explains how to use the glossary and in what order to finish a first pass.

    7 min
  2. 02
    What Is an AI Agent: From ChatGPT to AI That Acts on Its Own

    Break down the essence of AI Agents with four components — LLM, context, tools, and loop — contrast chatbots with Agents, walk through daily, developer, and business examples plus real failure modes, and learn to judge whether your needs actually call for an Agent.

    12 min1 prerequisite
  3. 03
    What Is a Terminal: The Name of Everything in That Window You Just Opened

    Every install guide's first line is 'open a Terminal.' You open it, see a dark window and a line of text, and don't know where to look next. This isn't a command list — it dissects the screen in front of you line by line: what that window is, why typing can make things happen, what the prompt is telling you, and the invisible but always-active 'current directory.'

    13 min1 prerequisite
  4. 04
    Terminal, Shell, CLI: The Difference Between the Three Terms, and Ten Survival Commands

    The first line of most AI-tool install guides is 'open a Terminal,' but nobody explains how Terminal, Shell, and CLI actually differ. This article separates the three terms, gives you ten commands that really are enough, shows you how to read error messages, and covers the habit that costs beginners the most.

    11 min1 prerequisite
  5. 05
    The AI Coding Tools Map: Recognize the Form Factor First, Memorize Names Later

    Cursor, Trae, Claude Code, Codex, OpenClaw, Hermes Agent, DeepSeek Harness, WorkBuddy and Doubao Work sorted into three categories by form factor: IDE-embedded, terminal agent, and orchestration platform. For each category: what it gives you, how much control and visibility it takes away, and how people actually mix them in practice — so you can decide which category your first tool should come from.

    13 min1 prerequisite
  6. 06
    Which AI Tool Should I Use: Four Questions and You Have Your Answer

    Not a comparison table — a decision tree. Ask four questions in order: what form of output you want from it, whether you are willing to touch a terminal, whether your data can go to a third party, and how long you plan to use it. Every branch points to the matching tool category and a specific article on this site.

    7 min1 prerequisite
  7. 07
    What Is Cursor: The AI Coding Tool That Lives in Your Editor

    Three everyday actions — Tab completion, the Agent panel, and Plan Mode — explain what Cursor is, how it differs from a chatbot and from a terminal agent, which platforms it supports, what its billing model looks like, and the three kinds of people who should not start with Cursor.

    8 min1 prerequisite
  8. 08
    Installing Cursor: From Download to Your First AI-Assisted Edit

    Follow this guide and you'll end up with a working Cursor on your machine: signed in to an account, a real project open, having watched it change a line of code with a diff you see yourself, and the command-line Cursor CLI installed. Every step spells out what you should see and what failure looks like.

    16 min1 prerequisite
  9. 09
    Git and GitHub for Beginners: Why AI Tools Keep Asking You to Clone

    Why every AI programming tool's installation guide assumes you know Git. This article explains what repository, commit, branch, clone, fork, and pull request each mean, how they connect, and why non-programmers need to understand the first three.

    9 min1 prerequisite
  10. 10
    Copying Commands from the Web into the Terminal: Why It Often Fails

    You copy a command from a tutorial, paste it into your terminal, and get a syntax error or command not found — this article explains the four most common reasons: smart quotes, truncated multi-line commands, invisible whitespace characters, and pasting into the wrong shell. Each comes with an immediate verification method.

    8 min1 prerequisite
  11. 11
    File Paths: Why Your File 'Cannot Be Found'

    The difference between absolute and relative paths, why macOS/Linux and Windows use different separators, what the home-directory shorthand is, why names with spaces need quotes, and how to find where a file actually is on your system. The five most common path errors with their verification methods.

    8 min1 prerequisite
  12. 12
    Install Didn't Work: Five Checks to Complete Before Reinstalling

    When a tool seems unresponsive after installation, it's almost always one of five reasons: not in PATH, insufficient permissions, network blocked, version mismatch, or low disk space. This guide provides a one-minute check for each reason and explains why 'reinstalling' is rarely the solution.

    9 min1 prerequisite
  13. 13
    How to Read an Error Message: Anatomy, Stack Traces, and Exit Codes

    Error messages aren't meant to be read word by word — they have a fixed shape: a concluding line, a stack trace, a filename with a line number, and an exit code. This article teaches why you read a stack trace bottom-up, how to find the line that actually failed, six real-shaped examples, and when to paste the whole thing into a search engine, when to give it to an AI Agent, and when to do neither.

    19 min1 prerequisite
  14. 14
    Installation Failures on Windows: PATH, Execution Policy, and SmartScreen

    When an AI-tool install stalls on Windows, the cause is almost always one of the same set: installed but the command can't be found (PATH), scripts blocked (PowerShell execution policy), or the installer blocked (SmartScreen or antivirus). This article shows you how to confirm whether the program actually got installed, where it put its files, and the one confirming action for each kind of block.

    19 min1 prerequisite
  15. 15
    Installation Failures on macOS: Gatekeeper, Quarantine Flags, and Missing Build Tools

    When an AI-tool install stalls on a Mac, it's usually one of four things: the wrong chip's build was downloaded, Gatekeeper says it can't verify the developer, the download is flagged as coming from the internet, or the command-line build tools are missing. This article gives you one confirming action for each, in order — including the things no guide tells you, like the 'Open Anyway' button sticking around for only about an hour.

    16 min1 prerequisite
  16. 16
    What an AI Agent Can Actually See on Your Computer

    Which files an AI Agent can read, whether it can go online, whether it can delete things, and whether what you say gets used for training. This article splits 'what can it do' into four separately verifiable questions, and explains what permission modes, sandboxes, and working directories each block — and don't.

    8 min1 prerequisite
  17. 17
    Is My Data Safe? What Actually Leaves Your Computer When You Use AI

    'Is it safe?' is too blunt a question to ever get a useful answer. This article breaks it apart: the four kinds of things that actually leave your machine when you use cloud tools, why local tools are different, what the sentence 'we don't train on your data' does and does not promise, and three rules you can actually enforce. No legal advice included.

    11 min1 prerequisite
  18. 18
    Your First AI Task: How to Give Instructions It Gets Right

    Why first tasks usually fail — not because the tool is weak, but because the instruction has no output, no input, and no destination. Three elements, three real examples (each with its vague version for contrast), and how to judge how much freedom to give.

    7 min1 prerequisite
  19. 19
    Your First Agent: A Hello World That Uses Tools

    Hand-write an Agent that actually does things, without any framework: it checks the weather, does arithmetic, and loops on its own until the task is complete. A step-by-step breakdown of the six steps of the Agent loop, its termination conditions, and the common pitfalls — once you've written it, you'll understand what frameworks do for you.

    29 min2 prerequisites
  20. 20
    How AI Pricing Works: Why One Month Could Cost Ten Times More

    What a token is, why long conversations get more expensive, what free tiers usually limit, how to choose between subscriptions and pay-as-you-go, and five concrete ways to keep your first month's cost near zero. No specific prices listed — this site only writes dollar amounts after manual verification.

    7 min1 prerequisite
  21. 21
    Config Files, Dotfiles, and Package Managers: What Are Those Files Starting with a Dot?

    Why every tool asks you to edit a file starting with a dot, the difference between YAML and JSON, why wrong indentation breaks everything, what problems package managers like brew and apt solve, and how much regex you actually need to know.

    11 min1 prerequisite
  22. 22
    Set Up Your LLM Dev Environment in Five Minutes

    Build a development environment that can call an LLM API from scratch: installing Python, virtual environments, getting an API key, and managing environment variables, then verifying the whole chain with a single curl command. Complete commands for both macOS and Windows, with a focus on keeping your key safe and out of git.

    15 min1 prerequisite
  23. 23
    How the Web Talks: HTTP, Status Codes, Headers, and Invisible Protocols

    Why API docs are full of status codes and headers. This article walks through a real request to clarify the four parts of HTTP — request, response, status code, header — then explains the difference between WebSocket and polling, why CORS blocks you, what a proxy does in the middle, and why SSH and private keys belong to the same family.

    11 min1 prerequisite
  24. 24
    APIs, SDKs and All Those Abbreviations: What Each One Is and When You Will Need It

    An API is a published agreement; an SDK is a toolkit in which someone has wrapped the details of calling that API for you. This piece spells out the difference between the two, why some tools require an API key and some do not, the distinction between REST and streaming, and whether you, as a user, ever need to write API calls yourself.

    8 min1 prerequisite
  25. 25
    What Is an API Key: It's Both Your Identity and Your Wallet

    An API key is a string that tells a remote service 'this request is yours, and the bill goes to you.' This article explains why it's a secret, where it belongs (environment variables or .env — never a chat window), what to do on leakage, why it's usually wired directly to money, and a distinction most beginners miss: logging into the web version is not the same as having an API key.

    10 min1 prerequisite
  26. 26
    Your First LLM API Call: Tokens, Billing, and Common Errors

    Send your first LLM request with Python's openai SDK: understand the division of labor among system, user, and assistant message roles; the trade-offs of temperature, max_tokens, and streaming; token billing concepts and usage estimation; and finally, a troubleshooting guide for the errors every beginner will meet.

    21 min1 prerequisite
  27. 27
    After You Press Enter: From 0.03 s to 0.85 s, What Your Question Goes Through

    One real API call dissects the full chain of a question: 35 ms to establish the connection, microseconds to tokenize, 474 ms for the model to read your whole question, 380 ms generating it token by token — 854 ms in total. Includes the complete reproducible measurement method, and one counterintuitive conclusion: 96% of the time is not in the network but inside the model.

    13 min1 prerequisite
  28. 28
    What Is Trae: ByteDance's AI IDE, and the Open-Source Agent That Shares Its Name

    Sorting out the three easily confused things called Trae: ByteDance's AI IDE (IDE mode and SOLO mode), the office assistant TraeWork, and the open-source trae-agent command-line framework on GitHub. With platform support, the billing model, and advice on picking between them.

    9 min1 prerequisite
  29. 29
    Installing Trae: Running Both IDE Mode and SOLO Mode Once

    ByteDance's AI IDE Trae (TraeCode), from downloading, initial setup, sign-in, and opening a project, to running one task each in IDE Mode and SOLO Mode and setting the permission mode. Every step spells out what you should see on screen, plus the real errors and fixes listed in the official docs.

    15 min1 prerequisite
  30. 30
    What Is Claude Code: The Reference Template for Terminal Agents

    The flow of one real session explains what Claude Code is: a coding agent that lives in your terminal, reading files, editing files, running commands and iterating until the task is done. With installation methods, the CLAUDE.md memory mechanism, form factors beyond the terminal, the billing model, and the three kinds of people who should not start with it.

    9 min1 prerequisite
  31. 31
    Installing Claude Code: A Getting-Started Path for the Terminal Agent

    Anthropic's official terminal coding agent Claude Code, from system requirements, four install methods (native install script, Homebrew, WinGet, npm), the verification command, and browser sign-in, to permission modes and your first change. Every step spells out the output you should see and the real error messages listed in the official docs.

    19 min1 prerequisite
  32. 32
    Understanding the Transformer Architecture: Attention Is All You Need

    An in-depth understanding of the core components of Transformer: Self-Attention, Multi-Head Attention, Positional Encoding, and how they replaced RNNs to become the foundational architecture of modern LLMs.

    7 min1 prerequisite
  33. 33
    Prompt Engineering Systematic Methodology: From Few-shot to ReAct

    A complete methodology for Prompt Engineering: principles and practical applications of techniques such as Few-shot, Chain-of-Thought, Tree-of-Thought, ReAct, and Self-Consistency.

    6 min1 prerequisite

Switch track

The tracks share the same articles, so progress here is not wasted — switching only changes the ordering and the extra lessons.

Back to all courses

Curriculum structure last updated 2026-11-08. Content is still being filled in; lessons marked “in progress” are not live yet.