🎓 Part of the free, open-source AI Career Curriculum ecosystem — Infrastructure · ML Engineering · AI Engineering · Governance · Startup · Workforce.
💜 Sponsor this curriculum — sponsorships keep the whole open-source AI Career Curriculum free and moving.
Status: ✅ Curriculum authored — 9 modules with lecture chapters and hands-on exercises, plus 3 capstone projects. Quizzes and labs are scaffolded and fill in on subsequent content cycles. AI-assisted content is under ongoing human review.
This is the entry rung of the Agentic track (level 20) and the on-ramp to the Agentic AI Engineer track (level 30). It teaches the LLM-application fundamentals that every higher agentic track assumes you already have, and maps directly to the high-volume "AI Engineer / LLM application developer" hiring title.
You start from a single LLM API call and finish by shipping a containerized, tool-using agent behind a validated API. Each module builds on the last: API mechanics → reliable prompts and structured output → tools that take action → retrieval over your own documents → a reason-act agent that ties it together → deploying the whole thing as a service. Three production-craft modules then harden it: streaming and async orchestration, model selection and cost control, and a minimal eval suite that catches regressions before users do.
- Call LLM APIs with a working mental model of tokens, context windows, temperature, streaming, cost, and robust error/retry handling
- Engineer prompts that hold up, produce schema-constrained JSON, and are validated and iterated against simple evals
- Wire tools and functions so the model can plan and act, with the call/result loop and malformed-argument handling under control
- Build retrieval — embeddings, similarity search, chunking, indexing, and a simple RAG query loop you can defend with a recall number
- Implement your first agent with the ReAct (Thought/Action/Observation) loop, retrieval-as-a-tool, and conversation memory
- Ship an LLM app as a FastAPI service with secrets management, structured logging, a cost/usage guardrail, and a Dockerfile
- Stream and orchestrate — consume SSE streams, parse partial JSON, fan out async calls under bounded concurrency, retry with backoff + jitter, and report honest TTFT / p95 latency
- Defend model choice and cost — small-vs-frontier benchmarks, per-call cost estimates and token budgets, prompt caching, cascade routing, and graceful degradation when a provider is down
- Gate features on evals — a golden set run as a pytest CI check, rule / similarity / LLM-judge scoring, and regression tracking across model and prompt changes
Nine modules (90 hours of module content). Every module ships lecture
chapters, three to five hands-on exercises, and a resources.md reading list.
Quizzes and labs are scaffolded and authored on subsequent content cycles.
| Module | Topic | Hours | Exercises | Quiz |
|---|---|---|---|---|
| mod-101 | LLM Fundamentals for Application Developers | 10h | 3 | Planned |
| mod-102 | Prompt Engineering & Structured Output | 10h | 3 | Planned |
| mod-103 | Tool & Function Calling | 10h | 3 | Planned |
| mod-104 | Retrieval Basics (Embeddings & Simple RAG) | 10h | 3 | Planned |
| mod-105 | Your First Agent: The Reason-Act Loop | 10h | 3 | Planned |
| mod-106 | Shipping an LLM Application | 10h | 3 | Planned |
| mod-107 | Streaming, Async, and Parallel LLM Orchestration | 12h | 5 | Planned |
| mod-108 | Model Selection, Cost, and Prompt Caching | 10h | 5 | Planned |
| mod-109 | Minimal Evaluation and Regression Checks for LLM Features | 8h | 4 | Planned |
Three capstones (50 hours combined) that compose the module skills end-to-end.
| Project | Focus | Hours | Builds On |
|---|---|---|---|
| project-101 | Ship an LLM-powered application — prompting, structured output, tool calling, and simple RAG behind a validated API with secrets management and a usage guardrail | 18h | mod-101 → mod-104, mod-106 |
| project-102 | A simple tool-using agent — a single ReAct loop with 2–3 tools, retrieval, and conversation memory; document where it breaks down (the bridge into the Engineer track) | 12h | mod-103 → mod-105 |
| project-103 | Multi-provider comparison report for one LLM feature — accuracy against a golden set, cost with prompt caching, and streaming latency across providers and model sizes, ending in a defended model-selection recommendation | 20h | mod-107 → mod-109 |
This is an entry-level track, but it assumes you can already write and run Python comfortably. Before starting you should have:
- Python — functions, classes, virtual environments,
pip, reading/writing files, and running scripts from a terminal - HTTP & JSON basics — what a request/response is, status codes, and parsing JSON
- Command line — navigating directories, environment variables, running commands
- Git basics — clone, branch, commit
- An API key — access to an LLM provider (e.g., Anthropic or OpenAI) for the exercises
No prior machine-learning, deep-learning, or agent experience is required — those concepts are introduced from first principles. See PREREQUISITES.md for the full assumed-skills list.
git clone https://github.com/ai-engineering-curriculum/agentic-ai-developer-learning.git
cd ai-infra-agentic-ai-developer-learningai-infra-agentic-ai-developer-learning/
├── lessons/mod-XXX-*/ modules: lecture chapters, exercises/, labs/, quizzes/, resources.md
├── projects/project-XXX-*/ multi-module capstones
├── CURRICULUM.md role-level coverage map
├── PREREQUISITES.md assumed entry skills
├── VERSIONS.md release history
└── README.md this file
# 1. Create and activate a virtual environment
python3.11 -m venv venv
source venv/bin/activate # Windows: venv\Scripts\activate
# 2. Set your LLM provider key
export ANTHROPIC_API_KEY="sk-..." # or OPENAI_API_KEY, per the exercise
# 3. Start with Module 101
cat lessons/mod-101-llm-fundamentals/README.md- Read the lecture chapters in order (the numbered
NN-*.mdfiles in each module). - Do the three exercises in
exercises/— each is a self-contained build with objectives and validation. - Skim
resources.mdfor deeper external reading. - Move to the next module only once you can complete its exercises unassisted.
- Build the capstones in
projects/once you've covered the modules they depend on.
Work the modules in numeric order — each one explicitly builds on the protocols and pipelines introduced in the previous module.
A working application-developer's mental model of LLM APIs: what a call is, what each knob does (temperature, sampling, model choice), what it costs, and how to handle failures. Covers chat/messages format, roles, streaming, token and context windows, cost/latency estimation, and error/rate-limit/retry handling.
Turns LLM API skills into a repeatable engineering practice: prompts that hold up, schema-constrained JSON you can parse, validation at the application boundary, and iteration against simple evals. Covers few-shot prompting, decomposition and reasoning, structured-output strategies, and output parsing.
Turns the model from a text generator into the planner of a small, auditable program. Covers tool-definition anatomy, the call/result loop, wiring Python functions as tools, deciding when a tool call is appropriate, and handling tool errors and malformed arguments safely.
Puts your documents in front of the model at query time. Builds both pipelines every retrieval system needs — an offline ingest that chunks, embeds, and indexes a corpus, and an online query loop that retrieves and assembles a grounded, cited answer — and evaluates retrieval quality with recall@K.
Combines the tool loop and the retriever into a first agent: a single model that decides, turn by turn, whether to act, retrieve, or answer. Implements the ReAct (Thought/Action/Observation) pattern on native tool-use APIs, wires retrieval in as a tool, adds conversation memory, and draws an honest line around the limits of a single agent.
Turns a laptop script into a service: a FastAPI process with Pydantic-validated requests, environment-managed secrets, structured logs that include token usage, a cost/usage guardrail, and a Dockerfile so the app runs the same way on another machine. Finishes with running the whole thing end-to-end and locally.
The wire and the runtime between "the model produced an answer" and "the user
saw it, fast." Consumes SSE streams from OpenAI and Anthropic, streams partial
structured output safely, fans out concurrent calls with asyncio + httpx
under a bounded concurrency limit, retries transient failures with backoff and
jitter, and reports time-to-first-token and p50 / p95 / p99 latency honestly.
Defends the model choice with numbers. Benchmarks small vs. frontier models across providers, estimates cost per feature call and enforces token budgets, turns on and measures provider prompt caching, routes requests by task shape (cascade, fast-first-then-escalate, batch), and plans graceful degradation for provider outages.
Keeps a shipped LLM feature working: a 20–50 example golden set, scored with rule-based, similarity, and calibrated LLM-as-a-judge checks, run as a required pytest CI gate, with run history that routes each regression to the commit, model, or prompt version that caused it.
Reference implementations for every exercise and project live in the paired solutions repository:
ai-infra-agentic-ai-developer-solutions
Try each exercise yourself first; consult the solutions repo to compare approaches once you have a working attempt.
This track is the on-ramp to the rest of the Agentic ladder:
- Agentic AI Developer (level 20) — you are here
- Agentic AI Engineer (level 30) — multi-agent systems, orchestration, evaluation
- Senior AI Engineer (level 40) and Systems Architect (level 48) — production agentic platforms at scale
Maintained by VeriSwarm.ai