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
- Build something every week, even something tiny.
- Read the official docs and release notes of the tools you use.
- Read one paper or engineering guide a month.
- Check claims: who says it, and where's the source?
- 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
- Why do you want to be an AI engineer rather than a researcher? Tie it to what you enjoy (building products) and your projects.
- 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).
- How do you keep up with AI? Weekly building, official docs and release notes, a paper or guide a month, checking sources.
- What's in your portfolio, and how do you know each project works? Name the evals or tests and their scores.
- 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).