---
title: "AI engineer roadmap: skills, projects, and resources by stage"
description: "A practical AI engineer roadmap in seven stages, each with the skills to learn, a project to ship, and resources worth the time, from Python to production."
summary: "An AI engineer roadmap is a sequenced plan for learning to build production software on top of foundation models. This guide splits the path into seven stages, from programming foundations to production systems, and gives each stage skills, a portfolio project, and a short list of resources."
type: "guide"
canonical_url: "https://theaiengineering.com/articles/ai-engineer-roadmap"
markdown_url: "https://theaiengineering.com/articles/ai-engineer-roadmap.md"
topic: "AI engineering"
author: "The AI Engineering Editors"
publisher: "The AI Engineering"
published: "2026-07-24"
updated: "2026-11-11"
keywords: ["ai engineer roadmap","how to become an ai engineer","ai engineer roadmap for beginners","ai engineer skills","ai engineer projects","how long does it take to become an ai engineer"]
citation: "The AI Engineering Editors. \"AI engineer roadmap: skills, projects, and resources by stage.\" The AI Engineering, updated Nov 11, 2026. https://theaiengineering.com/articles/ai-engineer-roadmap"
---

# AI engineer roadmap: skills, projects, and resources by stage

## TL;DR

- The most direct route into AI engineering runs through software engineering: programming, HTTP APIs, and testing come before models.
- A practical AI engineer roadmap has seven stages: programming foundations, LLM fundamentals, prompts and tool calling, retrieval, evals and observability, agents and MCP, and production systems.
- Each stage should end with a shipped project, and later stages should extend one growing project instead of starting a new toy each time.
- Evaluation belongs in the middle of the roadmap, before agents, because every later stage depends on measuring whether a change helped.
- Model training and deep ML math are optional depth for application-focused AI engineering, useful later for fine-tuning and inference work.

An AI engineer roadmap is a sequenced plan for learning to build production software on top of [foundation models](https://theaiengineering.com/glossary/foundation-model). This roadmap has seven stages, from programming foundations to production systems, and each stage lists the skills to learn, a project to ship, and the resources we consider worth the time. The roadmap assumes you want to build AI products, not train models; if the distinction is new, start with [what AI engineering is](https://theaiengineering.com/articles/what-is-ai-engineering) and the [AI engineering topic hub](https://theaiengineering.com/topics/ai-engineering).

## How to become an AI engineer: the roadmap at a glance

To become an AI engineer, build a software engineering base first, then learn to call models, control them through context and tools, ground them with retrieval, measure them with evals, extend them into agents, and run them in production. The order matters: each stage depends on the one before it, and one project should grow through all of them.

**Figure 1: The seven stages of the AI engineer roadmap, in dependency order.**

Seven stages in dependency order: Python and tooling, LLM APIs, prompts and tools, retrieval, then evals and tracing, agents and MCP, and production systems.

Components:

- **Python, APIs, Git**: Stage 0
- **LLM APIs, outputs**: Stage 1
- **Prompts, tools**: Stage 2
- **Retrieval and RAG**: Stage 3
- **Evals and tracing**: Stage 4
- **Agents and MCP**: Stage 5
- **Production systems**: Stage 6

Connections:

- Python, APIs, Git → LLM APIs, outputs
- LLM APIs, outputs → Prompts, tools
- Prompts, tools → Retrieval and RAG
- Retrieval and RAG → Evals and tracing
- Evals and tracing → Agents and MCP
- Agents and MCP → Production systems

| Stage | Focus | Project to ship | Ready to move on when |
|---|---|---|---|
| 0 | Programming foundations | A tested, containerized REST service | You can build, test, and deploy a small service alone |
| 1 | LLM fundamentals and model APIs | A document extraction CLI | You can predict token cost and get valid JSON back |
| 2 | Prompts, context, and tool calling | A tool-using assistant | Tool calls succeed on varied, messy inputs |
| 3 | Retrieval and RAG | Q&A over a docs set, with citations | You can report retrieval recall, not just answer quality |
| 4 | Evals and observability | An eval suite and tracing for Stage 3 | A CI job fails when quality drops |
| 5 | Agents and MCP | A bounded agent using your own MCP server | The agent stops reliably and asks before writes |
| 6 | Production systems | The project deployed behind a gateway | You can show cost, latency, and security data |

## Stage 0: Python and programming foundations

Stage 0 is the software base that every later stage assumes: one language used well, HTTP APIs, Git, SQL, testing, and deploying a small web service. Much of AI engineering work is integration code around model calls, so weak programming skill shows up in every later stage as slow progress and fragile projects.

**Learn:**

- Python: functions, classes, type hints, virtual environments, packaging, and `async`/`await`.
- HTTP and JSON: calling REST APIs, handling errors, retries, and timeouts.
- A web framework such as FastAPI, and data validation with Pydantic.
- Git, pull requests, and a basic CI pipeline.
- SQL and one relational database.
- Automated testing with pytest.
- Building and running a Docker container.

**Build:** a small REST service that wraps a public API, with typed request and response models, tests, and a Dockerfile.

**Resources:** the official Python tutorial, and the FastAPI and Pydantic documentation. Pydantic in particular reappears across AI tooling, including model SDKs and agent frameworks.

## Stage 1: LLM fundamentals and model APIs

Stage 1 builds an accurate mental model of how language models behave and how to call them from code. The goal is not training a model; the goal is predicting model behavior: why outputs vary between runs, how [tokens](https://theaiengineering.com/glossary/tokens) drive cost and limits, why long inputs degrade answers, and how to get structured data back reliably.

**Learn:**

- Tokens, tokenization, and the context window as a hard limit and a cost driver.
- Sampling parameters: temperature, top-p, and maximum output tokens.
- Transformer basics at a conceptual level: attention, next-token prediction, pretraining, and post-training.
- Calling at least two providers' APIs, with streaming, error handling, and rate-limit backoff.
- Structured outputs with JSON schemas, plus validation of what comes back.
- Reasoning models and when their extra latency and tokens are worth paying for.

**Build:** a command-line tool that extracts fields from invoices or emails into validated JSON. Run it with two different models on 50 documents and record accuracy, latency, and token cost for each.

**Resources:** Andrej Karpathy's "Neural Networks: Zero to Hero" video series for intuition about how models work; the Hugging Face LLM Course for transformers and the open-model ecosystem; and each model provider's API reference.

## Stage 2: Prompt engineering, context, and tool calling

Stage 2 teaches you to control model behavior through what goes into context and which functions the model can request. Prompt and context design is the main lever an AI engineer has without retraining, and tool calling is the bridge from generating text to triggering actions in software.

**Learn:**

- System prompts: role, scope, constraints, output format, and few-shot examples.
- [Context engineering](https://theaiengineering.com/articles/context-engineering): what to include on each call, how to trim history, and when to summarize.
- [Tool calling](https://theaiengineering.com/articles/tool-calling): function schemas, tool descriptions, malformed arguments, and parallel calls.
- Prompt versioning: storing prompts in the repository and reviewing changes like code.
- Prompt caching for long, repeated prefixes.

**Build:** an assistant that answers questions by calling two or three real APIs through tool calls, such as a weather service, a calendar, and a small database. Keep the prompt in version control and log every tool call.

**Resources:** the prompt engineering and tool-use guides published by the major model providers, read side by side to see which advice is provider-specific.

## Stage 3: Retrieval-augmented generation (RAG)

Stage 3 covers retrieval-augmented generation: finding the right passages in your own data and placing them in context, so the model answers from facts it was never trained on. Answer quality is capped by retrieval quality, because a model cannot cite a passage the search step never returned, so this stage measures search before tuning prompts.

**Learn:**

- [Embeddings](https://theaiengineering.com/glossary/embeddings) and similarity search.
- Chunking strategies, document metadata, and filtering.
- [Vector databases](https://theaiengineering.com/platforms/vector-databases) and their indexing tradeoffs.
- Hybrid search, combining keyword and vector results, followed by reranking.
- Retrieval metrics such as recall at k and mean reciprocal rank.
- Citations, and when to answer "not found" instead of guessing.

**Build:** a Q&A service over a documentation set, such as an open-source project's docs, that cites its sources. Label 50 questions with the passage that answers each, and report recall at 5 before and after adding hybrid search and reranking.

**Resources:** chapter 6, "RAG and Agents," of Chip Huyen's [AI Engineering (O'Reilly, 2025)](https://huyenchip.com/books/), and our explainer on [retrieval-augmented generation](https://theaiengineering.com/articles/what-is-rag).

## Stage 4: LLM evaluation and observability

Stage 4 turns experiments into engineering: building evaluation sets, scoring outputs automatically, running evals on every change, and tracing production requests. Evals come before agents on this roadmap because agents multiply the number of ways a system can fail, and measurement has to exist before that complexity arrives.

**Learn:**

- Designing eval sets from real usage, including edge cases and adversarial inputs.
- Scoring methods: exact checks, code assertions, [LLM-as-a-judge](https://theaiengineering.com/glossary/llm-as-a-judge), and human review.
- Calibrating a judge model against your own labels before trusting its scores.
- Regression testing: running evals in CI on every prompt, retrieval, or model change.
- Tracing: spans for model calls, retrieval, and tools, with tokens, latency, and cost on each.
- Online signals: user feedback, escalation rates, and task completion.

**Build:** add an eval suite to the Stage 3 project with at least 100 cases, a judge prompt checked against a hand-labeled sample, and a CI job that fails when scores drop. Add tracing so any bad answer can be followed back to the retrieval step or the prompt.

**Resources:** chapters 3 and 4 of Huyen's AI Engineering, which cover evaluation methodology and evaluating AI systems, plus our guides to [LLM evaluation](https://theaiengineering.com/articles/llm-evaluation) and [LLM observability](https://theaiengineering.com/articles/llm-observability).

## Stage 5: AI agents and MCP

Stage 5 covers agents: systems in which model output selects tool calls in a loop until a task is done. The skills are designing that loop, bounding it with step budgets and permissions, connecting tools through the Model Context Protocol, and recognizing when a fixed workflow would be simpler and more reliable than an agent.

**Learn:**

- The agent loop: model, tools, memory, planning, and stopping conditions, as covered in our explainer on [AI agents](https://theaiengineering.com/articles/what-are-ai-agents).
- Workflow patterns: prompt chaining, routing, parallelization, orchestrator-workers, and evaluator-optimizer.
- The [Model Context Protocol](https://theaiengineering.com/articles/what-is-model-context-protocol): writing an MCP server and connecting a client to one.
- One agent framework in depth, chosen after writing a basic loop by hand; our [agent framework comparison](https://theaiengineering.com/articles/ai-agent-frameworks) covers the options.
- Agent evals: task success rate, trajectory checks, and cost per task.
- Human approval steps for any action with side effects.

**Build:** an agent that completes a multi-step task, such as triaging new GitHub issues by reading, labeling, and drafting replies, through an MCP server you wrote. Give the agent a step budget and a cost cap, and require human approval before any write.

**Resources:** Anthropic's engineering post [Building effective agents](https://www.anthropic.com/engineering/building-effective-agents), which defines the workflow patterns above; the free [Hugging Face Agents Course](https://huggingface.co/learn/agents-course/unit0/introduction); and the MCP specification.

## Stage 6: LLMs in production

Stage 6 covers running AI systems for real users: gateways for routing and fallbacks, caching, cost and latency budgets, security against prompt injection, and, for teams that self-host, inference optimization. At this stage a working demo becomes a service with monitoring, budgets, and an owner who gets paged when the service fails.

**Learn:**

- [AI gateways](https://theaiengineering.com/articles/what-is-an-ai-gateway): routing, provider fallbacks, rate limits, key management, and budgets.
- Caching: prompt caching at the provider and semantic caching at the gateway.
- Security: prompt injection, sensitive data exposure, and least-privilege tool access.
- Latency: streaming, time to first token, and smaller models for easy requests.
- Self-hosting basics: serving engines, quantization, and KV cache behavior, covered in our guide to [LLM inference optimization](https://theaiengineering.com/articles/llm-inference-optimization).
- Optional depth: fine-tuning with LoRA, and when it beats retrieval.

**Build:** deploy the Stage 4 or Stage 5 project behind an open source gateway such as Bifrost or LiteLLM, with a fallback provider, per-user rate limits, and a cost dashboard. Add a prompt-injection test set to the evals and fix what it finds.

**Resources:** the [OWASP Top 10 for LLM Applications](https://genai.owasp.org/llm-top-10/), whose 2025 list includes prompt injection, excessive agency, and unbounded consumption; and chapters 7 through 9 of Huyen's AI Engineering, on finetuning, dataset engineering, and inference optimization.

## How long does it take to become an AI engineer?

The time depends mostly on Stage 0. A working software engineer already has that base and can treat Stages 1 through 6 as a focused part-time project measured in months. Someone new to programming should plan for Stage 0 alone to take longer than the AI-specific stages combined, because general software skill is the larger body of knowledge.

### Pacing by starting point

The table below is a planning assumption for part-time study alongside a job, not a guarantee. Adjust it after the first stage, once you know your own pace.

| Starting point | Where to start | Planning assumption |
|---|---|---|
| Professional software engineer | Stage 1 | Two to four weeks per stage, one growing project |
| Data scientist or ML practitioner | Stage 0 gaps (services, testing, deployment), then Stage 1 | Faster through Stages 1 and 4, slower on Stages 0 and 6 |
| New to programming | Stage 0 | Ship a Stage 0 project before touching model APIs |

### AI engineer projects for your resume

One project that grows across all seven stages is stronger evidence than seven unrelated demos. Reviewers can see the same system gain retrieval, evals, an agent, and production controls, and they can read the tradeoffs you made at each step.

Make each project easy to assess:

- A README that states the problem, the architecture, and the measured results.
- Eval numbers before and after each major change, with the eval set published.
- A trace or two showing a failure and how you fixed it.
- Cost and latency figures per request.
- A short section on what still fails and why.

## Where to go next

When you reach Stage 4, the [LLM evaluation guide](https://theaiengineering.com/articles/llm-evaluation) goes deeper on eval design. For Stage 5, compare the options in our guide to [AI agent frameworks](https://theaiengineering.com/articles/ai-agent-frameworks) before committing to one. To see how the seven stages map onto the real job, read [what AI engineering is](https://theaiengineering.com/articles/what-is-ai-engineering).

## Frequently asked questions

### What programming language should I learn to become an AI engineer?

Learn Python first. Python dominates AI tooling, including model provider SDKs, retrieval libraries, evaluation tools, and most agent frameworks. TypeScript is the strong second choice, especially for engineers building web products, since the major model providers and several agent frameworks ship official TypeScript libraries. Pick one language, learn it well enough to build and test a web service, then add the other when a project needs it.

### Do AI engineers need math?

Application-focused AI engineering needs less math than model research. Basic probability and statistics matter for evaluation, because you compare pass rates and need to know when a difference is noise. Linear algebra helps you understand embeddings and similarity search. Calculus and optimization theory matter mainly if you move into training, fine-tuning, or inference optimization, which this roadmap treats as optional depth.

### How to become an AI engineer with no experience?

Start with Stage 0 of the roadmap: learn one programming language, HTTP APIs, Git, SQL, and testing, and deploy a small web service. Then work through the AI-specific stages with one project that grows over time, and publish the code, eval results, and a short write-up of what failed. Measured, public projects are the most direct way to show ability without prior job experience.

### Can you become an AI engineer in 6 months?

An experienced software engineer can cover the AI-specific stages of this roadmap in a few months of focused part-time work, because the programming base already exists. Someone starting without programming experience will usually need longer, since Stage 0 is a full discipline on its own. Hiring outcomes depend on the job market and employers, which no learning plan controls.

### Do AI engineers need DSA or LeetCode?

Data structures and algorithms are general programming skills, and they help with the integration code that makes up most AI engineering work. Whether you need LeetCode-style practice depends on the interview process at the companies you target, which varies widely. Projects that show retrieval, evaluation, and production judgment demonstrate the AI-specific skills that generic coding rounds do not test.

## Terms in this guide

- [Tokens](https://theaiengineering.com/glossary/tokens): Tokens are the units of text a language model processes, typically whole words, word fragments, punctuation, or bytes, each mapped to an integer ID from the model's fixed vocabulary.
- [Context window](https://theaiengineering.com/glossary/context-window): A context window is the maximum number of tokens a language model can take into account in a single request, including the system prompt, conversation history, tool results, and the generated output.
- [Structured outputs](https://theaiengineering.com/glossary/structured-outputs): Structured outputs is an LLM API feature that constrains generation so the model's response always conforms to a developer-supplied JSON Schema, producing output that code can parse without retries.
- [Embeddings](https://theaiengineering.com/glossary/embeddings): Embeddings are fixed-length vectors of numbers that represent data such as text or images so that items with similar meaning sit close together, which lets software compare meaning with arithmetic.
- [Hybrid search](https://theaiengineering.com/glossary/hybrid-search): Hybrid search is a retrieval method that runs keyword search, typically BM25, and vector similarity search on the same query and merges the two ranked lists into one result set.
- [LLM-as-a-judge](https://theaiengineering.com/glossary/llm-as-a-judge): LLM-as-a-judge is an evaluation method in which a language model scores or compares the outputs of an LLM application against a rubric, a reference answer, or another response, replacing or supplementing human graders.
- [Prompt injection](https://theaiengineering.com/glossary/prompt-injection): Prompt injection is an attack in which text supplied to a large language model, typed by a user or hidden in content the model reads, alters the application's intended behavior or output.
- [Fine-tuning](https://theaiengineering.com/glossary/fine-tuning): Fine-tuning is the process of further training a pretrained model on a smaller, task-specific dataset so its weights change to improve performance on a particular task, domain, style, or output format.
- [Foundation model](https://theaiengineering.com/glossary/foundation-model): A foundation model is a large AI model trained on broad data, usually with self-supervised learning at scale, that can be adapted through prompting or fine-tuning to a wide range of downstream tasks.
- [Context rot](https://theaiengineering.com/glossary/context-rot): Context rot is the decline in a language model's accuracy and recall as the number of tokens in its input grows, even when the information a task needs is present in the context.
- [Pretraining](https://theaiengineering.com/glossary/pretraining): Pretraining is the first stage of training a language model, in which it learns to predict the next token across a large unlabeled corpus of text and code, producing a general-purpose base model.
- [LLM streaming](https://theaiengineering.com/glossary/llm-streaming): LLM streaming is the delivery of a language model's output in small chunks as it is generated, usually as server-sent events over HTTP, so clients can show text before the response is complete.
- [Rate limiting](https://theaiengineering.com/glossary/rate-limiting): Rate limiting is the enforcement of a maximum number of requests or tokens a client may send to an API within a time window, with excess requests rejected, usually with HTTP 429.
- [JSON Schema](https://theaiengineering.com/glossary/json-schema): JSON Schema is a declarative vocabulary, itself written in JSON, for describing the structure of JSON data; LLM APIs and MCP use it to define tool arguments and constrain model output.
- [System prompt](https://theaiengineering.com/glossary/system-prompt): A system prompt is the set of developer-written instructions sent to a language model ahead of the conversation, defining its role, rules, output format, and tool use for every turn that follows.
- [Few-shot prompting](https://theaiengineering.com/glossary/few-shot-prompting): Few-shot prompting is a technique that puts a few example inputs paired with desired outputs in a prompt, so a language model infers the task, format, and labels without changing its weights.
- [Approximate nearest neighbor search](https://theaiengineering.com/glossary/approximate-nearest-neighbor): Approximate nearest neighbor (ANN) search is a family of indexing methods that find vectors close to a query vector without comparing it to every stored vector, accepting that some true nearest neighbors are missed.
- [Recall@k](https://theaiengineering.com/glossary/recall-at-k): Recall@k is a retrieval metric that measures the fraction of a query's relevant documents that appear in the top k results, averaged over a set of test queries.
- [Golden dataset](https://theaiengineering.com/glossary/golden-dataset): A golden dataset is a curated, versioned set of representative inputs, each paired with an expected output or grading criteria, that a team treats as ground truth when evaluating an LLM application.
- [Agent orchestration](https://theaiengineering.com/glossary/agent-orchestration): Agent orchestration is the control logic that decides which agent, model call, or tool runs next in an AI system and what each receives, whether written in code or chosen by a model.
- [Human-in-the-loop](https://theaiengineering.com/glossary/human-in-the-loop): Human-in-the-loop (HITL) is an agent design in which the run pauses at defined checkpoints, such as before a sensitive tool call, so a person can approve, edit, or reject the action.
- [Model failover](https://theaiengineering.com/glossary/model-failover): Model failover is the automatic rerouting of an LLM request to a backup model, deployment, or provider when the primary target returns an error, times out, or hits a rate limit.
- [Inference engine](https://theaiengineering.com/glossary/inference-engine): An inference engine is the software that serves a trained language model: it loads the weights, batches incoming requests, manages KV cache memory, runs the forward passes, and streams generated tokens over an API.

## Related guides

- [What is AI engineering? The discipline, the stack, and the work](https://theaiengineering.com/articles/what-is-ai-engineering): What is AI engineering? A plain definition, how it differs from ML and software engineering, the layers of the stack, and what AI engineers do day to day.
- [LLM evaluation: a practical guide to evals, metrics, and judges](https://theaiengineering.com/articles/llm-evaluation): LLM evaluation for engineers: build eval datasets, pick metrics, calibrate LLM-as-a-judge, evaluate RAG and agents, and gate every release in CI.
- [What are AI agents? How agents work and when to use one](https://theaiengineering.com/articles/what-are-ai-agents): AI agents are LLM systems that call tools in a loop until a task is done. Learn how the loop works, agents vs agentic AI, examples, failure modes, and limits.
- [What is retrieval-augmented generation (RAG)? How RAG works](https://theaiengineering.com/articles/what-is-rag): Retrieval-augmented generation (RAG) grounds LLM answers in your documents. Learn the RAG pipeline, hybrid search, agentic RAG, evaluation, and failure modes.

Part of the [AI engineering](https://theaiengineering.com/topics/ai-engineering) topic hub.

## Cite this guide

The AI Engineering Editors. "AI engineer roadmap: skills, projects, and resources by stage." The AI Engineering, updated Nov 11, 2026. https://theaiengineering.com/articles/ai-engineer-roadmap

- Title: AI engineer roadmap: skills, projects, and resources by stage
- Author: The AI Engineering Editors
- Publisher: The AI Engineering
- Published: 2026-07-24
- Updated: 2026-11-11
- URL: https://theaiengineering.com/articles/ai-engineer-roadmap
- Markdown: https://theaiengineering.com/articles/ai-engineer-roadmap.md

To cite one section, link to its anchor:

- [How to become an AI engineer: the roadmap at a glance](https://theaiengineering.com/articles/ai-engineer-roadmap#how-to-become-an-ai-engineer-the-roadmap-at-a-glance)
- [Stage 0: Python and programming foundations](https://theaiengineering.com/articles/ai-engineer-roadmap#stage-0-python-and-programming-foundations)
- [Stage 1: LLM fundamentals and model APIs](https://theaiengineering.com/articles/ai-engineer-roadmap#stage-1-llm-fundamentals-and-model-apis)
- [Stage 2: Prompt engineering, context, and tool calling](https://theaiengineering.com/articles/ai-engineer-roadmap#stage-2-prompt-engineering-context-and-tool-calling)
- [Stage 3: Retrieval-augmented generation (RAG)](https://theaiengineering.com/articles/ai-engineer-roadmap#stage-3-retrieval-augmented-generation-rag)
- [Stage 4: LLM evaluation and observability](https://theaiengineering.com/articles/ai-engineer-roadmap#stage-4-llm-evaluation-and-observability)
- [Stage 5: AI agents and MCP](https://theaiengineering.com/articles/ai-engineer-roadmap#stage-5-ai-agents-and-mcp)
- [Stage 6: LLMs in production](https://theaiengineering.com/articles/ai-engineer-roadmap#stage-6-llms-in-production)
- [How long does it take to become an AI engineer?](https://theaiengineering.com/articles/ai-engineer-roadmap#how-long-does-it-take-to-become-an-ai-engineer)
- [Where to go next](https://theaiengineering.com/articles/ai-engineer-roadmap#where-to-go-next)
- [Frequently asked questions](https://theaiengineering.com/articles/ai-engineer-roadmap#faq)
