Key points
- Learn in order: computing basics, Python, the web and APIs, language models, automation, agents, retrieval, then multi-agent work.
- Finish one small project at every stage before moving to the next.
- Reading English documentation slowly and carefully is a core skill, not a side skill.
- Three small finished projects that solve real problems are worth more than a long list of courses.
- The biggest waste of time is hopping between tutorials and chasing every new tool.
1. How to read this guide
This is general advice for someone studying on their own. It is a suggested order, not a syllabus, and it is not a description of any particular course. You can change the tools. The order is the part worth keeping, because each stage depends on the one before it.
No stage has a time limit here. Some students finish a stage in two weeks and others need two months, depending on how many hours they have and what they already know. The only rule is that a stage is finished when its project works, not when the videos are watched.
2. Stage one: computing basics and reading English documentation
Many students skip this stage and pay for it later. Before any programming, you should be comfortable with files and folders, file extensions, installing and removing software, zip files, keyboard shortcuts and typing at a reasonable speed. You should know the difference between a file saved on your computer and a file saved online.
The second half of this stage is reading. Almost all technical documentation and almost every error message is in English. You do not need to speak fluently. You need to read a paragraph of instructions slowly, look up the words you do not know and follow the steps exactly. This is a skill and it improves with practice.
Project: choose a free tool you have never used, read its official "getting started" page from top to bottom, and install it using only that page. Then write a half-page note in your own words, in English or Urdu, explaining what you did and where you got stuck.
3. Stage two: a first programming language
Choose Python. It reads close to plain English, it is free, it runs on old computers, and most AI tools and examples are written in it. Learn variables, conditions, loops, functions, lists and dictionaries, reading and writing files, and how to install and import a library. Learn to read an error message from the bottom line upward before asking anyone for help.
Type every example yourself. Copying and pasting teaches your eyes but not your hands. When an example works, change something and predict what will happen before you run it.
Project: a marks calculator. The program reads a text or CSV file of student names and subject marks, works out totals, percentages and grades, and writes a result file. It is small, but it uses every basic idea, and you can check the answers by hand.
4. Stage three: how the web and APIs work
An agent is useful because it can reach other systems, and it reaches them through the web. Learn what happens when you open a web page: your browser sends a request to a server and gets a response. Learn the common request types, what a status code tells you, and what JSON looks like. JSON is the format most programs use to exchange data.
An API is simply a web address meant for programs instead of people. You send a request and get data back. Learn what an API key is and treat it like a password. Never put it in a screenshot, a shared file or a public code repository.
Project: a script that calls a free public API, such as a weather or prayer-times service, for your own city and prints a tidy one-line summary. Then make it handle failure politely when the internet is down.
5. Stage four: using language models well
Before building with a language model, learn to use one properly. A model predicts likely text from what you give it. It does not look things up unless it has a tool for that, and it can state wrong things in a confident voice. Knowing this shapes everything you build later.
Practise writing clear instructions: say who the output is for, give the material to work from, give an example of the result you want and ask for a fixed format. Then learn to call a model from Python through an API, so that your program sends text and receives text. Many providers offer a free or low-cost tier that is enough for learning.
Project: a notes summariser. Give it a chapter of your own class notes and have it return five key points and three practice questions in a fixed format. Then check every point against the notes and record what it got wrong. That checking habit is the real lesson.
If you cannot tell when the model is wrong on a topic you know, you are not ready to trust it on a topic you do not know.
6. Stage five: a first automation with a visual tool
A visual automation tool such as n8n lets you connect steps by drawing them: when this happens, do that, then do the next thing. It teaches triggers, steps, data moving between steps and what to do when a step fails. These are the same ideas agents use, and you can see them on screen.
Start with an automation that has no AI in it at all. Then add one model step in the middle. You will see quickly that most of the work is ordinary plumbing and that the model is one part among several.
Project: a form-to-sheet workflow. When someone submits an enquiry form, the workflow saves the row to a spreadsheet, uses a model to label the enquiry as admission, fee or other, and sends a short acknowledgement email. A tuition centre or a small shop could use this the same week.
7. Stage six: a first agent with tools
In an automation, you decide the steps. In an agent, the model decides which step to take next, choosing from tools you have given it. A tool is just a function with a clear name and description, for example "look up the price of an item" or "add two numbers". The model reads the request, picks a tool, reads the result and continues until it can answer.
Write your first agent in Python with two or three tools. Libraries such as LangChain can help, but try the simplest version by hand once so you understand the loop. Add a limit on the number of steps, and print every step so you can see what the agent did and why.
Project: a shop assistant agent. Give it a small price list in a file, a tool to look up an item and a calculator tool. Ask it questions such as the total for three items with a discount. Then ask for an item that is not on the list and make sure it says so instead of inventing a price.
8. Stage seven: retrieval over your own documents
A model does not know your school's fee policy or your shop's return rules. Retrieval fixes this. You split your documents into small pieces, store them so that pieces can be found by meaning, find the pieces most related to a question and give those pieces to the model along with the question. The store is usually called a vector store.
The details that matter are practical ones: how large the pieces are, whether the right piece is actually being found, and whether the answer names the piece it came from. When an answer is wrong, check first what was retrieved. Very often the model answered correctly from the wrong piece.
Project: a question-answering tool over one real document you are allowed to use, such as a prospectus or a course outline. Every answer must show the passage it used, and the tool must say "not found in the document" when that is the case.
9. Stage eight: multi-agent basics
A multi-agent system gives different parts of a job to different agents, for example one that drafts and one that checks. Frameworks such as CrewAI are built for this. The useful lesson at this stage is restraint. More agents mean more cost, more waiting and more places for mistakes, so each agent should have a clear reason to exist.
Project: a two-agent writer and checker. The first agent drafts a short product description from a list of facts. The second compares the draft with the facts and lists anything added or changed. Then build the same thing with one agent and compare the results honestly. Sometimes the single agent is good enough, and it is worth seeing that for yourself.
10. A portfolio of three small real projects
By now you have eight practice projects. Choose the three best ideas and make each one real, which means one actual person uses it. A relative's shop, a tuition centre, a mosque committee, a clinic reception desk or your own class group will all do. Real users find problems that you never will.
For each project, write one page: the problem, what you built, what it does not do, and what went wrong on the way. Keep the code in an online repository with clear instructions for running it. An honest list of limits makes a project more believable, not less.
- One automation that saves somebody real time each week.
- One agent that uses tools and refuses to guess.
- One retrieval project over real documents, with sources shown.
11. Practising on a slow connection or a shared computer
A fast laptop and unlimited internet are helpful but not required. Python and a light code editor run on modest machines. Most model work happens on the provider's servers, so your computer only sends and receives text. The real difficulties are data, load-shedding and limited hours on a shared machine, and each has a workaround.
- Download documentation and lessons as text or PDF when you have a connection, and read them offline.
- Prefer written tutorials to video. They use far less data and are faster to search.
- Keep your work on a USB drive or in an online repository so you can continue on any computer.
- Plan on paper first. Write the steps of your program by hand, then use your computer time for typing and testing.
- A phone is fine for reading and for chatting with a model, but do your programming on a keyboard whenever you can.
- Save often, and log out of every account on a shared computer. Never leave an API key saved on it.
12. Common ways students waste months
The most common trap is tutorial-hopping. A student watches a beginner course, feels unsure, and starts another beginner course in a different language. Months later they have started five courses and built nothing. Watching feels like progress because it is comfortable. The discomfort of a blank file and an error message is where the learning actually happens.
The second trap is chasing every new tool. Something new is announced every week and each one is described as essential. The foundations change slowly: programming, APIs, clear instructions, tools, retrieval and checking outputs. A student who knows those can pick up a new tool in days. A student who knows only tool names has to start again each time.
- Collecting certificates instead of finished projects.
- Copying a project from a video and presenting it without understanding it.
- Asking a model to write all your code in stage two, before you can read what it wrote.
- Studying alone for months without showing anyone your work.
- Waiting for the perfect laptop, course or moment to begin.
13. Studying alone or with teachers
Everything in this guide can be learned from free material, and many people do it that way. What self-study lacks is feedback and a fixed pace. If you study alone, find one or two others at the same stage and review each other's projects every week.
Some people learn better with teachers, deadlines and classmates. For them, TIDES runs a 4-month, project-based AI Automation & Agentic Mastery bootcamp in Lahore. Either way, the test is the same at the end: can you take a small real problem and build something that works for the person who has it.
