The guide · roadmap
Become an AI engineer in 6 months.
A practical, month-by-month roadmap with every resource you need — no CS degree required. Six months, six focus areas: coding and fundamentals, LLM app development, RAG, agents and evals, deployment and production, then specialise and get hired. Each month has a clear goal, the exact resources to learn from, and a build-it project to prove you can.
The full 6-month roadmap
🔒 Drop your email to reveal the full roadmap
Get the full roadmap, free.
Drop your email and all six months of resources unlock instantly, plus every other guide and resource in the library. One email a week, unsubscribe anytime.
Month 1: Coding & fundamentals
Goal: become a functional Python developer who can write clean code, use the terminal, call APIs, and manage a codebase.
Python
- Python for Everybody (Coursera) — best starting point for absolute beginners.
- freeCodeCamp Python Course (YouTube) — comprehensive 4-hour video.
- CS50P: Intro to Programming with Python (Harvard) — rigorous, with problem sets.
- Official Python Tutorial — authoritative reference.
Focus on: variables, data types, loops, functions, lists, dicts, file I/O, JSON, classes, error handling, venv, pip.
Git & GitHub
- GitHub Skills — interactive courses built inside GitHub.
- Learn Git Branching — best visual tool for branches and merges.
- Pro Git Book — comprehensive reference.
Focus on: init, add, commit, push, pull, branching, .gitignore, README files.
CLI / terminal
- 50 Most Popular Linux & Terminal Commands (YouTube) — beginner-friendly.
- The Missing Semester (MIT) — shell scripting and terminal fluency.
JSON, APIs, HTTP & async
- HTTP Basics — MDN Web Docs — clearest HTTP explanation.
- REST API Tutorial — short and practical.
- Python Requests Library — call any web API.
- Python async/await (Real Python) — essential for streaming LLM responses.
SQL & Pandas
- SQLBolt — fastest way to learn SQL, 20 short lessons.
- Pandas Getting Started — official guide.
- Kaggle Pandas Course — hands-on, short.
FastAPI
- FastAPI Official Tutorial — one of the best framework docs ever written.
- Python API Development (freeCodeCamp, 19hr) — full API from scratch.
🔨 Practice project: build a CLI tool that calls a public API and formats results as JSON.
Month 2: LLM app development
Goal: build real AI-powered applications using OpenAI and Anthropic APIs with reliable prompts, structured outputs, tool calling, and streaming.
Prompting fundamentals
- Anthropic Interactive Prompt Engineering Tutorial — 9 chapters with exercises.
- Anthropic Prompt Engineering Docs — official reference.
- OpenAI Prompt Engineering Guide — official OpenAI guide.
- PromptingGuide.ai — comprehensive techniques.
Structured outputs / JSON schemas
- OpenAI Structured Outputs Guide — force models to match schemas.
- Instructor Library — cleanest way to get structured outputs via Pydantic.
- OpenAI Cookbook: Structured Outputs Intro — real-world examples.
Function / tool calling
- OpenAI Function Calling Guide — definitive reference.
- Anthropic Tool Use Docs — Claude's tool calling.
- OpenAI Cookbook: Function Calling with Chat Models — full notebook.
Streaming responses
- OpenAI Streaming Docs — stream=True reference.
- Anthropic Streaming Docs — Python examples.
- How Streaming LLM APIs Work — Simon Willison — technical breakdown.
Conversation state
- OpenAI: Managing Conversations — messages array explained.
- Anthropic Messages API Docs — same concept, different syntax.
Cost, latency & tokens
- OpenAI Pricing — cost per model.
- Anthropic Pricing — Claude model costs.
- OpenAI Tokenizer Tool — interactive token counter.
- Tiktoken (Python) — count tokens in code.
Failure handling
- OpenAI Error Codes Reference — every error type.
- Anthropic Error Handling Docs — Claude errors.
- Tenacity (Python) — retry logic with exponential backoff.
Prompt injection awareness
- OWASP Top 10 for LLM Apps — Prompt Injection — authoritative classification.
- OWASP Prompt Injection Prevention Cheat Sheet — defensive patterns.
- Evidently AI: What is Prompt Injection — developer-focused explainer.
🔨 Practice project: build a multi-tool assistant with get_weather(), calculate(), and search_notes() functions.
Month 3: RAG (retrieval-augmented generation)
Goal: build systems that let LLMs answer questions from your documents with grounded, cited answers.
Embeddings
- Stack Overflow: Intuitive Introduction to Text Embeddings — best beginner explanation.
- Google ML Crash Course: Embeddings — why dense vectors work.
- HuggingFace: Getting Started With Embeddings — hands-on guide.
- OpenAI Embeddings Guide — API reference.
Chunking
- Weaviate: Chunking Strategies for RAG — most practical guide.
- Unstructured: Chunking Best Practices — technical deep-dive.
- LangChain Text Splitters — practical reference.
Vector databases
- Chroma Docs — perfect for prototyping, runs locally.
- Pinecone Learning Center — great tutorials (provider-agnostic).
- Qdrant Documentation — best open-source for production.
- pgvector — vector search in PostgreSQL.
Metadata filtering
- Pinecone: Metadata Filtering Guide — clear code examples.
- LlamaIndex: Metadata Filters — query-time filtering.
Reranking
- Cohere Reranking Docs — best starting point.
- LangChain: Cohere Reranker Integration — wire into LangChain.
Retrieval quality & hallucination
- LangChain: Query Transformations — query rewriting, HyDE.
- Pinecone: Improving Retrieval Quality — common failure modes.
- Zep: Reducing LLM Hallucinations — developer guide.
- Voiceflow: 5 Ways to Reduce Hallucinations — combined strategies.
Citations & grounding
- Anthropic: Giving Claude Sources — cited responses.
- LangChain: RAG with Sources — return source documents.
RAG frameworks
- LlamaIndex: Introduction to RAG — 5 key stages.
- LlamaIndex Starter Tutorial — working RAG in 30 lines.
- LangChain: Build a RAG Agent — full pipeline with reranking.
🔨 Practice project: build a "chat with your docs" app with FastAPI, a vector DB, reranking, and cited answers.
Month 4: Agents, workflows & evals
Goal: build AI systems that take autonomous actions, wire multi-step workflows, and evaluate performance.
Agent loops
- Anthropic: Building Effective Agents — single best resource on agents.
- OpenAI: Practical Guide to Building Agents (PDF) — patterns and guardrails.
- freeCodeCamp: Open Source LLM Agent Handbook — comprehensive practical guide.
- LangChain Academy: Intro to LangGraph — free course on agent orchestration.
Tool selection
- OpenAI: Function Calling Best Practices — writing reliable tool descriptions.
- Anthropic: Tool Use Best Practices — when to force vs auto-select.
State management
- LangGraph: State Management — definitive reference.
- DataCamp: LangGraph Agents Tutorial — hands-on fundamentals.
- Real Python: LangGraph in Python — complete stateful agent build.
Retries, failure handling & when NOT to use agents
- LangGraph: Error Handling and Retries — tool-node retry logic.
- OpenAI Agents Guide: Guardrails — layered defense.
- Anthropic: When to Use Agents — decision framework.
- Simon Willison: Designing Agentic Loops — when complexity is justified.
Multi-step workflows
- Anthropic: Workflow Patterns — chaining, routing, parallelization.
- LangGraph: Multi-Agent Networks — supervisor and handoff patterns.
Evaluation
- DeepEval — open-source eval framework (pytest-style).
- Promptfoo — CLI for testing LLM apps.
- LangSmith — tracing, debugging, evaluation.
- Ragas — RAG-specific evaluation (faithfulness, relevancy).
- Hamel Husain: Your AI Product Needs Evals — building real eval pipelines.
- OpenAI Evals Framework — community-contributed patterns.
🔨 Practice project: build a 3-step content pipeline — extract facts → generate posts in parallel → score and pick the best.
Month 5: Deployment & production
Goal: deploy AI apps that handle real users, real traffic, and real failures.
FastAPI production
- FastAPI Deployment Docs — Uvicorn, Gunicorn, Docker.
- FastAPI Production Deployment Guide (CYS) — Nginx, health checks, rate limiting.
- FastAPI Best Practices (FastLaunchAPI) — async pooling, Redis, JWT.
Docker
- Docker Getting Started — images, containers, Compose.
- freeCodeCamp: Multi-Agent AI with Docker — end-to-end tutorial.
- DataCamp: Deploy LLM Apps with Docker — LLM-specific guide.
- Docker for LLM Apps (ApXML) — multi-stage builds.
Background jobs
- Celery Getting Started — standard Python task queue.
- FastAPI Background Tasks — lightweight built-in option.
Auth & security
- FastAPI Security Docs — OAuth2, JWT, API keys.
- OWASP API Security Top 10 — authoritative risk list.
- Auth0: API Auth Best Practices — implementation guide.
Logging & observability
- Langfuse — open-source LLM observability.
- LangSmith — LangChain tracing and monitoring.
- Python Structlog — structured JSON logging.
Prompt & version management
- Langfuse Prompt Management — centralized prompt versioning.
- Anthropic Prompt Management — best practices at scale.
Cost monitoring
- OpenAI Usage Dashboard — track spending by model.
- Anthropic Usage Dashboard — Claude API usage.
- Helicone — proxy-based cost tracking.
- LiteLLM — unified interface, budget management.
Caching
- Redis Docs — standard in-memory data store.
- GPTCache — semantic caching for LLM apps.
🔨 Practice project: containerize your RAG app with docker-compose (FastAPI + vector DB + Redis).
Month 6: Specialise & get hired
Choose one of three directions and focus on practice.
Direction 1: AI product engineer (best for startup jobs)
- Vercel AI SDK — AI-powered UIs with streaming.
- Streamlit — data apps in pure Python.
- Gradio — quick ML/AI interfaces.
- Google: People + AI Guidebook — human-AI interaction design.
- Nielsen Norman Group: AI UX — research-backed guidelines.
Direction 2: Applied ML / LLM engineer (best for deeper technical roles)
- Google ML Crash Course: Fine-tuning vs Prompting — decision framework.
- Codecademy: Prompt Engineering vs Fine-Tuning — use cases.
- IBM: RAG vs Fine-Tuning vs Prompt Engineering — complete decision space.
- OpenAI Fine-tuning Guide — easiest way to start.
- HuggingFace Transformers Fine-tuning — open-source models.
- Unsloth — 2x faster fine-tuning, 80% less memory.
- LLaMA-Factory — fine-tune 100+ LLMs.
- Ollama — run open-source LLMs locally.
- HuggingFace Model Hub — largest model repository.
- vLLM — high-throughput LLM serving.
- HuggingFace: Optimizing LLM Inference — KV-cache, quantization.
- NVIDIA TensorRT-LLM — max inference performance.
Direction 3: AI automation engineer (best for building for businesses immediately)
- n8n — visual workflow automation with AI nodes.
- LangGraph: Multi-Agent Workflows — code-first orchestration.
- Temporal — durable workflow engine.
- Zapier AI Actions — connect AI to 6,000+ apps.
- Make (Integromat) — advanced visual automation.
- OpenAI Cookbook: AI Email Processing — email classification patterns.
- LangChain: Document Processing — 80+ document sources.
🔨 Practice project: build an end-to-end lead qualification system — scrape → research → score → draft outreach → log to CRM.
What AI engineers earn
| Level | Salary range |
|---|---|
| Junior (entry) | $90,000 – $130,000 |
| Mid-level (3-5 years) | $155,000 – $200,000 |
| Senior | $195,000 – $350,000+ |
| Average (Glassdoor) | $184,757 |
| Freelance specialty | Rate |
|---|---|
| AI Agent Development | $175 – $300/hr |
| RAG Implementation | $150 – $250/hr |
| LLM Integration | $125 – $200/hr |
Market stats: AI job postings grew 25% year-over-year; there's a 56% wage premium for AI skills versus non-AI roles; only 1% of companies are AI-mature; and 26% projected job growth through 2034.
Original guide by Artem Novitckii. More from him on Instagram, in the Skool community, and across his resource library.