SyntaxPilot
Courses/AI: Zero to Agents/Lesson 40
Video coming soonThis lesson’s video is being made

Start with the notes below; the video appears here as soon as it is on YouTube.

AI: Zero to Agents · Lesson 40 of 40

AI careers and roadmap

queued

These are the notes for AI episode 40, the final episode of the SyntaxPilot AI course. You've gone from "what is AI" to building, protecting, testing and designing agents. Now: which AI jobs exist, what each needs, and how to turn that into a plan you actually finish, with projects as proof. Every Python example runs as-is in the SyntaxPilot compiler; outputs and errors are real (Python 3.13). Hours per course or skill are toy numbers: yours will differ.

Real-life example: planning a trip, not collecting maps

A trip Your AI career
Pick the destination (Goa, not "somewhere") Pick a role
Plan the route (Pune before Goa) Order the skills: basics before advanced
Photos of the places Projects: proof you can build

Problem: tutorial hell

saved = ["Python A-Z", "Maths for ML", "Deep Learning 1", "Deep Learning 2",
         "Statistics", "SQL", "Computer Vision", "NLP", "LLMs", "MLOps",
         "Cloud", "Spark", "Reinforcement Learning", "GANs", "Agents"] * 4
HOURS_EACH = 25                      # a typical course
PER_DAY = 1                          # Rohan studies 1 hour a day

days = len(saved) * HOURS_EACH / PER_DAY
print("courses saved :", len(saved))
print("days to finish:", days)
print("years         :", round(days / 365, 1))
print("projects built:", 0)

Output:

courses saved : 60
days to finish: 1500.0
years         : 4.1
projects built: 0
  • Tutorial hell: endlessly watching courses and tutorials without building anything of your own. Without a destination everything looks important, so you learn everything slowly and never ship.

The main AI jobs

Role What they do Core skills In this course
AI engineer builds products on top of LLMs: chatbots, RAG, agents Python, LLM APIs, RAG, agents, evals, Git episodes 20-39
ML engineer trains models and runs them in production (MLOps) Python, ML, PyTorch, MLOps, SQL episodes 2-11
Data scientist answers business questions with data, statistics and ML Python, statistics, SQL, ML, charts episodes 2-7
AI researcher invents new methods and models maths, deep learning, PyTorch, papers; often a master's or PhD episodes 8-19
Every developer uses AI tools well and knows their limits prompting, checking output, safety episodes 19-22, 34-35
  • MLOps: the practices and tools for deploying, monitoring and updating ML models in production.

What the numbers say

  • The World Economic Forum's Future of Jobs Report 2025 (January 2025, data from over 1,000 companies) expects 170 million new roles to be created and 92 million displaced by 2030, a net increase of 78 million. The fastest-growing skills: AI and big data, then networks and cybersecurity. Nearly 40% of the skills required on the job are set to change.
  • In India, LinkedIn reported (April 2026) that AI engineering job postings grew 59.5% year on year, faster than the US, UK, France and Germany; its Jobs on the Rise 2026 list put AI engineer as the fastest-growing role in Hyderabad.

Job postings are not a promise of a job, but the direction is clear: AI skills plus the ability to build.

Step 1: pick the closest role

ROLES = {                              # what each job needs most
    "AI engineer":    {"python", "llm apis", "rag", "agents", "evals", "git"},
    "ML engineer":    {"python", "ml basics", "pytorch", "mlops", "sql", "git"},
    "Data scientist": {"python", "statistics", "sql", "ml basics", "charts"},
    "AI researcher":  {"python", "maths", "pytorch", "papers", "deep learning"},
}
rohan = {"python", "git", "sql", "llm apis"}      # what he knows today

for role, needs in ROLES.items():
    have = rohan & needs
    print(f"{role:15} {len(have)}/{len(needs)}  learn: {sorted(needs - rohan)}")

Output:

AI engineer     3/6  learn: ['agents', 'evals', 'rag']
ML engineer     3/6  learn: ['ml basics', 'mlops', 'pytorch']
Data scientist  2/5  learn: ['charts', 'ml basics', 'statistics']
AI researcher   1/5  learn: ['deep learning', 'maths', 'papers', 'pytorch']
  • rohan & needs (set intersection): what he already has.
  • needs - rohan (set difference): what's left to learn.

Rohan is 3 of 6 away from AI engineer and likes building apps, so that's his destination: three skills, not sixty courses.

Let job posts pick the skills

Compare a real-looking job post with Rohan's skills:

post = "Must have: Python, LLM APIs, RAG, Evals, Docker"   # a real-looking job post
rohan = {"python", "git", "sql", "llm apis"}

needed = set(post.split(": ")[1].split(","))
print("post asks for:", sorted(needed))
print("Rohan has    :", rohan & needed)

Output:

post asks for: [' Docker', ' Evals', ' LLM APIs', ' RAG', 'Python']
Rohan has    : set()

Nothing matches, because ' RAG' (with a space) and 'LLM APIs' (capitals) are different strings from 'rag' and 'llm apis'. Put both sides in the same format:

post = "Must have: Python, LLM APIs, RAG, Evals, Docker"
rohan = {"python", "git", "sql", "llm apis"}

def skills(text):                    # same format for both sides
    return {s.strip().lower() for s in text.split(",")}

needed = skills(post.split(": ")[1])
print("post asks for:", sorted(needed))
print("Rohan has    :", sorted(rohan & needed))
print("to learn     :", sorted(needed - rohan))

Output:

post asks for: ['docker', 'evals', 'llm apis', 'python', 'rag']
Rohan has    : ['llm apis', 'python']
to learn     : ['docker', 'evals', 'rag']
  • Normalisation: putting text into one standard form (trimmed, lowercase) before comparing.
  • Docker: a tool that packages an app with everything it needs so it runs the same on any computer.

Do this with ten real job posts for your role and count which skills appear most: that's your learning list, from the market rather than guesswork.

Step 2: order the skills (topological sort)

Some skills need others first. A topological sort orders items so each comes after everything it depends on. Python's standard library has it: graphlib.TopologicalSorter.

from graphlib import TopologicalSorter

NEEDS = {                            # skill: what you must know first
    "llm apis": {"python"},
    "rag":      {"llm apis", "embeddings"},
    "embeddings": {"rag"},           # oops: each one "needs" the other
    "agents":   {"rag", "llm apis"},
    "evals":    {"agents"},
}
print(list(TopologicalSorter(NEEDS).static_order()))

Output:

Traceback (most recent call last):
  File "main.py", line 10, in <module>
    print(list(TopologicalSorter(NEEDS).static_order()))
          ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/usr/local/lib/python3.13/graphlib.py", line 244, in static_order
    self.prepare()
    ~~~~~~~~~~~~^^
  File "/usr/local/lib/python3.13/graphlib.py", line 106, in prepare
    raise CycleError(f"nodes are in a cycle", cycle)
graphlib.CycleError: ('nodes are in a cycle', ['rag', 'embeddings', 'rag'])
  • Dependency graph: items and the "needs" arrows between them.
  • Cycle: A needs B and B needs A, so there's no place to start: graphlib.CycleError.

Fixed (embeddings need only Python, episode 13; RAG needs LLM APIs and embeddings, episode 24):

from graphlib import TopologicalSorter

NEEDS = {                            # skill: what you must know first
    "llm apis":   {"python"},
    "embeddings": {"python"},
    "rag":        {"llm apis", "embeddings"},
    "agents":     {"rag", "llm apis"},
    "evals":      {"agents"},
}
order = list(TopologicalSorter(NEEDS).static_order())
print("learn in this order:", " -> ".join(order))

Output:

learn in this order: python -> llm apis -> embeddings -> rag -> agents -> evals

That's this course's order too: each step uses the one before it.

Step 3: one project per skill

ROADMAP = [                          # (skill, hours, a project that proves it)
    ("llm apis",   15, "a college FAQ chatbot"),
    ("embeddings", 10, "a class-notes search by meaning"),
    ("rag",        20, "a rule-book question bot"),
    ("agents",     25, "a research assistant (episode 39)"),
    ("evals",      10, "20 test questions for it"),
]
PER_DAY = 1                          # still 1 hour a day
day = 0
for skill, hours, project in ROADMAP:
    day += hours / PER_DAY
    print(f"by day {day:>3.0f}: {skill:10} -> build {project}")
print(f"\n{day:.0f} days, {len(ROADMAP)} projects (before: 1500 days, 0 projects)")

Output:

by day  15: llm apis   -> build a college FAQ chatbot
by day  25: embeddings -> build a class-notes search by meaning
by day  45: rag        -> build a rule-book question bot
by day  70: agents     -> build a research assistant (episode 39)
by day  80: evals      -> build 20 test questions for it

80 days, 5 projects (before: 1500 days, 0 projects)

Learn one thing, build one thing. A portfolio (your public collection of projects) is the proof certificates can't give.

Step 4: make the portfolio reviewer-ready

projects = [
    {"name": "faq-chatbot",    "readme": True,  "demo": True,  "tests": False},
    {"name": "notes-search",   "readme": False, "demo": False, "tests": False},
    {"name": "research-agent", "readme": True,  "demo": True,  "tests": True},
]
for p in projects:                   # what a reviewer checks in 30 seconds
    missing = [k for k in ("readme", "demo", "tests") if not p[k]]
    print(f"{p['name']:15}", "add: " + ", ".join(missing) if missing else "ready")

Output:

faq-chatbot     add: tests
notes-search    add: readme, demo, tests
research-agent  ready
  • README: the first file in a repo: what it does, why, how to run it, and results.
  • Demo: a link, GIF or short video showing it working.
  • Tests / evals: proof it works (episode 36).

Three finished projects beat ten half-finished ones.

A README outline

# Research assistant (course capstone)
What: answers questions from my documents and cites every line.
Why: the plain model guessed; this one reads sources.
How to run: python agent.py "Why did canteen sales drop?"
Design: plan -> search -> guard -> notes -> write -> verify; step limit + budget.
Results: 10 evals, 10/10 passing; average cost per answer: Rs 2.50.
What failed and how I fixed it: search always returned a doc -> return None.

Your first 30 days

Week Do
1 Pick a role; read 10 job posts for it
2 Finish one small project
3 Add a README, a demo and tests
4 Post about it; ask for feedback

One hour a day beats ten hours once a month.

Show your work

  • Push every project to GitHub with a clear README.
  • Write one short post per project: what failed and how you fixed it.
  • Join communities and help others: answering questions teaches fast.
  • Practise explaining a project out loud: the problem, your design, the trade-offs, the results.

Interview questions an AI engineer gets (and where this course answers them)

Question Episodes
Why RAG and not fine-tuning? 17, 24
How do you know your app works? 25, 36 (evals)
How do you reduce hallucinations? 19, 24, 38
What stops your agent doing damage? 35 (least privilege, approval, guards)
What does each answer cost, and how do you cut it? 12, 16, 23 (tokens)
Workflow or agent for this task? 27, 37
How do you handle personal data? 38 (minimise, redact, delete)

The road you travelled: the whole course

Part Episodes Topics
How machines learn 1-11 AI vs ML vs DL, learning types, classification, metrics, overfitting, gradient descent, neurons, neural networks, deep learning, hyperparameters
How LLMs work 12-19 tokens, embeddings, attention and Transformers, LLMs, temperature and context, fine-tuning and RLHF, multimodal, limits
Using LLMs 20-25 prompting, better prompts, reasoning models, calling an LLM from code, RAG, evaluating AI apps
Agents 26-37 what an agent is, the loop, tools and function calling, MCP, memory, planning and reflection, your first agent, multi-agent, coding/browser agents, safety, observing and evaluating, design patterns
Responsibly, for real 38-40 responsible AI, the capstone, careers

Keep learning

  1. Build something every week, even something tiny.
  2. Read the official docs and release notes of the tools you use.
  3. Read one paper or engineering guide a month.
  4. Check claims: who says it, and where's the source?
  5. Next on SyntaxPilot: the hands-on Generative AI Engineering and Machine Learning courses.

Glossary

Term Meaning Example from this episode
AI engineer builds products on top of LLMs Rohan's destination
ML engineer trains and deploys models PyTorch, MLOps
Data scientist answers questions with data, statistics and ML SQL, charts
AI researcher invents new AI methods maths, papers
MLOps deploying, monitoring and updating ML models "ML engineer" skills
Tutorial hell watching courses without building 60 courses, 0 projects
Roadmap an ordered plan of skills and projects ROADMAP
Set intersection items in both sets (&) what Rohan has
Set difference items in one set but not the other (-) what's left to learn
Dependency something that must come first RAG needs embeddings
Dependency graph items plus "needs" arrows NEEDS
Topological sort ordering so every item follows its dependencies TopologicalSorter
Cycle a loop of dependencies with no start rag -> embeddings -> rag
CycleError graphlib's error for a cycle nodes are in a cycle
Portfolio your public collection of projects three GitHub repos
README a repo's front page: what, why, how to run the outline above
Demo a working example people can see a link or GIF
Job posting an advertised opening +59.5% AI engineering postings
Normalisation putting text in one standard form before comparing .strip().lower()
Docker packages an app so it runs the same anywhere in the job post

Common mistakes

Mistake What you see Why Fix
Save every course first days to finish: 1500.0, projects built: 0 no destination pick one role
Advanced topics first / circular plan graphlib.CycleError no order, no start basics before advanced
Only collect certificates no projects no proof one project per skill
Half-finished repos add: readme, demo, tests reviewers can't judge it README, demo, tests
Compare skills without normalising Rohan has : set() ' RAG' ≠ 'rag' .strip().lower() both sides
Learn alone, show nothing nobody knows your work no visibility posts, communities, explaining
Chase every new model always starting over hype, not a plan check sources, keep the route

Mini project: your own roadmap

Write one Python file with: your skills set, the four roles, the closest role (practice 1), your NEEDS graph sorted with TopologicalSorter (practice 2), and three projects with finish dates (practice 3). Commit it to GitHub as roadmap.py with a README, and update it every month.

Practice

1. Run the role check with your own skills and print the closest role.

Solution
ROLES = {
    "AI engineer":    {"python", "llm apis", "rag", "agents", "evals", "git"},
    "ML engineer":    {"python", "ml basics", "pytorch", "mlops", "sql", "git"},
    "Data scientist": {"python", "statistics", "sql", "ml basics", "charts"},
    "AI researcher":  {"python", "maths", "pytorch", "papers", "deep learning"},
}
me = {"python", "sql", "statistics", "charts"}       # put YOUR skills here

best = max(ROLES, key=lambda r: len(me & ROLES[r]) / len(ROLES[r]))
for role, needs in ROLES.items():
    print(f"{role:15} {len(me & needs)}/{len(needs)}  learn: {sorted(needs - me)}")
print("closest role:", best)

Output:

AI engineer     1/6  learn: ['agents', 'evals', 'git', 'llm apis', 'rag']
ML engineer     2/6  learn: ['git', 'ml basics', 'mlops', 'pytorch']
Data scientist  4/5  learn: ['ml basics']
AI researcher   1/5  learn: ['deep learning', 'maths', 'papers', 'pytorch']
closest role: Data scientist

2. Write a bigger NEEDS graph and sort it.

Solution
from graphlib import TopologicalSorter

NEEDS = {
    "ml basics":     {"python", "statistics"},
    "pytorch":       {"python", "ml basics"},
    "deep learning": {"pytorch"},
    "llm apis":      {"python"},
    "embeddings":    {"python"},
    "rag":           {"llm apis", "embeddings"},
    "tools":         {"llm apis"},
    "agents":        {"tools", "rag"},
    "evals":         {"agents"},
}
print(" -> ".join(TopologicalSorter(NEEDS).static_order()))

Output:

statistics -> python -> ml basics -> llm apis -> embeddings -> pytorch -> tools -> rag -> deep learning -> agents -> evals

3. Plan three projects with real finish dates.

Solution
from datetime import date, timedelta

start = date(2026, 11, 9)                     # a Monday
projects = [("college FAQ chatbot", 15), ("rule-book question bot", 20),
            ("research assistant + evals", 35)]   # (project, hours)
PER_DAY = 1
day = start
for name, hours in projects:
    day += timedelta(days=hours / PER_DAY)
    print(f"{name:28} done by {day:%a %d %b %Y}")

Output:

college FAQ chatbot          done by Tue 24 Nov 2026
rule-book question bot       done by Mon 14 Dec 2026
research assistant + evals   done by Mon 18 Jan 2027

4. Write a README for your capstone. Use the outline in "A README outline" above and fill in your own numbers.

Quick quiz 1

Neha loves building apps, knows Python and APIs, and wants to ship a college-notes chatbot. Which role fits best?

Answer

B: AI engineer. Next steps: RAG, agents and evals, one project each.

Quick quiz 2

NEEDS = {
  "agents": {"tools"},
  "tools":  {"agents"},
}

What's wrong with this plan?

Answer

B: it's a cycle, so there's no place to start and TopologicalSorter raises CycleError. Tools come first (they need only Python and LLM APIs), then agents.

Interview questions

  1. Why do you want to be an AI engineer rather than a researcher? Tie it to what you enjoy (building products) and your projects.
  2. Tell me about a project that failed at first. Use the course pattern: the obvious attempt, what failed on screen, why, the fix, the result (with numbers).
  3. How do you keep up with AI? Weekly building, official docs and release notes, a paper or guide a month, checking sources.
  4. What's in your portfolio, and how do you know each project works? Name the evals or tests and their scores.
  5. What would you build first in our team? The simplest thing that works (episode 37), measured with evals.

Summary

  • Collecting courses without a destination is tutorial hell (1500 days, 0 projects).
  • Pick the closest role you'd enjoy (set intersection and difference).
  • Order the skills: basics before advanced (topological sort; fix cycles).
  • One project per skill; make each reviewer-ready with a README, demo and tests.
  • Show your work, practise explaining, and keep learning with sources you can check.
  • AI skills are among the fastest-growing in demand (WEF 2025), and AI engineering postings in India grew 59.5% in a year (LinkedIn, April 2026).

That's the end of the AI course: from zero to AI agents. Thank you for learning with SyntaxPilot!

Sources (fetched 6 Nov 2026): World Economic Forum, "Future of Jobs Report 2025: 78 Million New Job Opportunities by 2030 but Urgent Upskilling Needed to Prepare Workforces" (press release, January 2025); Telangana Today, "AI engineering jobs in India surge 59.5 pc, outpacing US and Europe: LinkedIn report" (24 Apr 2026); Telangana Today, "AI Engineer fastest-growing job role: LinkedIn Jobs on the Rise 2026" (22 Jan 2026).