If you can already ship software, you are closer to an AI engineering role than most job descriptions suggest. You don't need a PhD or a research background. You need to build, harden, and ship systems that use large language models — and be able to explain and defend them in an interview. Here's the 2026 version of that path: what changed, the skills in order, a 90-day plan you can run around a full-time job, and the artifacts that turn learning into offers.
TL;DR
- Learn five layers in sequence — LLM fundamentals, RAG, agents, production skills, delivery — each one building on the last.
- Ship three artifacts while you learn: a production RAG service, a tool-using agent, and an eval harness that scores both.
- Budget about 90 days at 8–10 focused hours a week; reserve the last two weeks for packaging and interview prep.
What changed heading into 2026
The fundamentals are stable, but the bar moved. Four shifts matter for how you plan your learning:
- Agents went mainstream. Tool-using, multi-step systems are now table stakes, not a novelty. Employers expect you to reason about planning, memory, tool design, and safety — and, just as much, to know when a boring deterministic workflow beats an agent. "I built an agent" impresses nobody anymore; "I bounded the agent with scoped tools, a step budget, and human approval for destructive actions" does.
- Evals are non-negotiable. "It looks good" doesn't ship. Teams want people who can build a golden dataset, score outputs with a mix of deterministic checks and LLM judges, and gate prompt or model changes on the results in CI. If you learn one skill that most self-taught candidates skip, make it this one.
- Context got cheaper, retrieval stayed essential. Bigger context windows didn't kill RAG. Stuffing an entire corpus into a prompt is slow, expensive, and measurably less accurate on the long tail than retrieving the right passages. Grounding, citations, and cost control still win — long context is one tool, not the whole toolbox.
- Production ownership is the differentiator. Latency budgets, cost per request, observability, retries, and prompt-injection defense separate hobby projects from hireable work. Interviews now probe exactly this: not "can you build a demo" but "what broke when you ran it, and what did you do?"
None of this requires new math. It requires engineering discipline applied to a new kind of dependency — which is why working software engineers are well positioned.
The skills that matter (in order)
Learn in this sequence — each layer builds on the last. For every layer: what to learn concretely, what "good" looks like, and the kind of resource that teaches it well.
1. LLM fundamentals
Learn: tokens and tokenization, context windows, embeddings as semantic vectors, decoding parameters (temperature, top-p, max tokens), prompt structure (system vs user vs retrieved content), structured output and JSON mode, and the anatomy of an API call — streaming, errors, rate limits.
Good looks like: you can estimate the token cost and rough latency of a request before sending it, you know why an output got truncated, and you can get reliable structured output from a model instead of parsing prose with regex.
Resource: the official docs and prompting guides from one major model provider, read end to end, plus a concept reference you revisit as you build — the glossary covers the terms in plain language.
2. RAG
Learn: chunking strategies (fixed-size vs structure-aware, overlap), embedding model selection, vector indexes, hybrid search (vector plus keyword), metadata filtering, reranking, grounded generation with citations, and retrieval evaluation.
Good looks like: when an answer is wrong, you debug retrieval-first — you log the chunks returned for the failing query before touching the prompt. You can measure retrieval hit rate on a small golden set and defend your chunking choice with numbers, not vibes.
Resource: a build-along tutorial that takes one RAG system from ingestion to a deployed, cited, evaluated service — the production RAG walkthrough is exactly that shape. The RAG track structures the same material as lessons.
3. Agents
Learn: function calling and tool schema design, planner–executor loops, short-term vs long-term memory, when a fixed workflow beats an agent (most of the time), guardrails — allowlisted actions, validated parameters, max iterations, per-run budgets — and human-in-the-loop approval for destructive operations.
Good looks like: you default to a workflow and reach for an agent only when the steps genuinely can't be predetermined, and every agent you ship is bounded: scoped tools, step limits, and a full trace of every call.
Resource: build one small agent from scratch — a loop, a tool registry, a stop condition — before adopting any framework; the from-scratch agent build walks through it. Then the agents track adds memory, planning, and safety.
4. Production
Learn: evaluation (golden sets, deterministic checks, LLM judges validated against human labels), tracing and observability, retries with backoff and model fallbacks, semantic caching, cost and latency budgets per feature, and prompt-injection defense in depth.
Good looks like: every prompt, model, or index change runs an eval suite in CI and fails the build on regression. You can state your cost per request and p95 latency from a dashboard, not a guess.
Resource: engineering blogs and conference talks from teams operating LLM features at scale — search for postmortems and eval write-ups rather than launch announcements, and study how they measure.
5. Delivery
Learn: a lean API layer (FastAPI or Express), streaming responses, Docker, secrets management, a job queue for ingestion, and one cloud deployment path you know end to end.
Good looks like: a stranger can clone your repo and have the system running locally in five minutes, with no keys in the code and a one-command setup.
Resource: the deployment and containerization docs of one cloud provider, followed literally once. Resist collecting infrastructure tutorials — one shipped deployment teaches more than five read ones.
Notice what's missing from all five layers: training foundation models from scratch. That's research. Most hiring is for people who apply models well — see AI Engineer vs ML Engineer vs GenAI Developer.
A realistic 90-day timeline
Around a full-time job — call it 8–10 hours a week — this is achievable in about a quarter. Each week below ends with a concrete output; if you can't point to the output, don't move on.
Weeks 1–3: fundamentals and the first RAG app.
-
Week 1 — LLM basics. Output: a small CLI that calls a model API, handles errors and rate limits, streams the response, and logs tokens and estimated cost per call:
model=mid-tier input_tokens=812 output_tokens=143 cost_usd=0.003 latency_ms=940 -
Week 2 — Ingestion and retrieval. Output: a pipeline that chunks a real document set (your team's docs, a public handbook), embeds it, and stores it in a vector index with metadata.
-
Week 3 — Generation with citations. Output: a working chat-with-your-docs service that answers with cited sources and abstains when retrieval comes up empty. That's project one, version zero.
Weeks 4–6: harden it into something you'd defend.
- Week 4 — Evals. Output: a golden set of 50 or more questions with known-good answers, plus a script that scores retrieval hit rate and faithfulness, wired into CI.
- Week 5 — Observability and resilience. Output: tracing on every request, retries with backoff, and structured logs of failures you actually review.
- Week 6 — Cost and latency. Output: measured cost per query, a p95 latency number, a cache for repeated questions, and a README with an architecture diagram and trade-off notes. Project one is done.
Weeks 7–9: build an agent.
- Week 7 — The loop. Output: an agent that completes a real multi-step task (triaging issues, researching a topic across sources) with two or three tools.
- Week 8 — Guardrails. Output: scoped tool permissions, an allowlist for writes, human approval for destructive actions, and a handful of prompt-injection tests proving retrieved content can't hijack the agent.
- Week 9 — Agent evals. Output: a task-success eval set, reviewed traces of failed runs, and a README that states what the agent refuses to do. Project two is done.
Weeks 10–12: package and prepare.
- Week 10 — The eval harness. Output: extract your eval scripts into a standalone harness that runs against both projects. That's project three — and the strongest signal in the portfolio.
- Week 11 — The portfolio pass. Output: every repo runnable in five minutes, architecture diagrams, trade-off sections, and real cost numbers in each README.
- Week 12 — Interview mode. Output: two rehearsed project stories, one mock system-design round answered out loud, and a first pass through a real question bank.
The full week-by-week plan with lesson links lives in the AI Engineer Roadmap — grab it and follow along.
The projects that get you hired
Titles don't get offers; artifacts do. Aim for three, and judge each by what it demonstrates — this is the checklist reviewers actually run through in the ten minutes they give your repo:
- A production RAG service. Must demonstrate: a golden-set eval with real scores committed to the repo, answers with citations, an architecture diagram, a trade-offs section (why this chunking, this vector store, this model), and a cost-per-query number. The specs on the projects hub are written to this bar.
- A tool-using agent that does something real, safely. Must demonstrate: scoped tools and an action allowlist, a trace showing it recovering from a tool error, a task-success eval, and an honest limitations section — what it refuses, where it fails.
- An eval harness. Must demonstrate: a dataset, scoring code, CI integration, and ideally a README note about a regression it caught. Few candidates have one; it's the artifact that moves you from "tutorial follower" to "engineer" in a reviewer's head.
All three share the same README baseline: five-minute setup, no secrets in the repo, and a "what I'd do with more time" section. Each also doubles as an interview story. See 5 AI projects that get you hired.
How the roadmap maps to the interview loop
Every layer above answers a specific interview round — that's by design:
- Technical Q&A draws on layers 1–4. The AI engineer interview questions post has worked answers at the bar you should hit.
- System design is you narrating project one's architecture: requirements, layers, trade-offs, evals, and cost math out loud.
- The take-home is graded against the same checklist your repos already meet — README, architecture, evals, trade-offs.
- The behavioral round is your project two story told as problem, constraints, trade-offs, results — with numbers.
The interview prep hub turns that into a practice schedule. The point: you don't finish learning and then start prepping. The 90 days are the prep.
Start today
Pick your on-ramp on the Learn hub, or if you're brand new, read how to become an AI engineer first. Then open the roadmap and ship week one's output — a script that calls a model and logs what it costs — before the week ends. Momentum beats completeness.
FAQ
Is it too late to start in 2026?
No — and in one way it's easier than starting in 2023. The stack has standardized: the skills above are a known, finite list, and job descriptions finally agree with each other. What changed is the bar: a weekend demo no longer stands out, but a 90-day build with evals still does, because most candidates don't do it. Demand for applied roles remains strong — the salary breakdown has the current ranges.
Do I need to know ML theory?
Conceptual, yes; mathematical, rarely. You should be able to explain what an embedding is, why transformers attend, what fine-tuning changes, and what a token is. Nobody hiring for applied roles will ask you to derive attention. If a loop demands deep math, it's a research role wearing an AI engineer title.
Are certifications worth it?
As a tiebreaker, sometimes; as a substitute for artifacts, never. A cloud or vendor cert can get a resume past an automated filter at a large company, and the studying isn't wasted. But in interviews a cert without a project loses to a project without a cert every time — the project is what generates defensible answers. Do the 90 days first; add a cert only if your target employers list one.
How do I show skill without job experience in AI?
With public artifacts and the ability to discuss them at depth. Say it plainly — "my current role doesn't touch LLMs, so I built this on my own" — then show the architecture, the eval scores, and what broke. Interviewers count a serious self-directed project as real experience because it is. What they reject is tutorial clones presented as experience, and the difference shows in the first follow-up question.
How much Python vs TypeScript?
Both are viable; the ecosystem leans Python. Most agent frameworks, eval tooling, and research code are Python-first, so you need to read it fluently even if you don't love it. TypeScript is a legitimate choice for the application layer, and its tooling is catching up fast. Practical rule: build in whichever language you ship fastest in, but don't let the portfolio be your first Python — write at least one of the three projects in it.