AI Learning Guide: The Order for Prompts, Python and Machine Learning

Learning AI starts with using generative AI tools through well-built prompts, then moves on to Python, linear algebra and basic statistics before you train a first machine learning model in scikit-learn. This hub breaks that journey into 7 steps and 10 topics, from writing a prompt all the way to a neural network in TensorFlow or PyTorch.

1 guides available

AI Groundwork

Five Skills You Build While Learning AI

Each skill grows out of the one before it, so the order matters.

Writing precise instructions

Learners practise prompts that carry context, an instruction, a format and examples, then test what the model returns and note where generative AI gets things wrong. That builds a feel for how models behave before any code is written. The core drill gives one task three prompt versions and lays the answers side by side to see which part made the output better.

Python logic for data

Variables, lists, loops and functions are learned while cleaning small data tables. Python is the main interface of the most widely used machine learning libraries, such as scikit-learn, TensorFlow and PyTorch. Early exercises involve loading a CSV with pandas, dropping empty rows and summarising each column, until a learner can write a 20 to 50 line program without copying an example.

Just enough maths

Linear algebra explains vectors and matrices, and basic statistics covers means, spread, correlation and probability. Together they are enough to follow how a model learns from data. Each formula is tried in a notebook with NumPy straight away, so numbers that felt abstract on paper turn into arrays and charts you can actually look at.

Training and judging models

Students tell supervised from unsupervised learning, train a classification or regression model in scikit-learn, then check it against data the model has never seen. Accuracy, precision and recall are read alongside a confusion matrix, which reveals when a model only looks good because it has memorised its training data.

Building apps on top of models

At the advanced stage, learners call pre-trained models through an API, connect an LLM to their own documents with RAG and present the result in a simple web app such as Streamlit. This draws on every earlier skill: tidy prompts, readable Python and the habit of testing model output before anyone else relies on it.

The Full AI Guide

Ten Topics in Learning AI: Prompts, Model Evaluation and Deployment

The ten parts below each cover one AI skill, such as writing a prompt or reading a model metric: what the skill involves, where model output usually goes wrong, which exercises build it, and how a learner can tell the habit has stuck.

Anatomy of a Prompt: Context, Instruction, Format and Examples

A useful prompt can be broken into four parts. Context says who the output is for and how it will be used. The instruction names the task with a clear verb such as summarise, compare or list. The format sets the shape of the answer: a three-column table, five bullet points, a paragraph under 100 words. Examples show the pattern you expect, and they are what separates zero-shot prompting (no examples) from few-shot prompting (a handful of examples, often two to five).

Beginners tend to type one short sentence and feel let down by what comes back. The cause is nearly always a missing part. The model has no idea how advanced the reader is, so it pitches the explanation too high, or it has no length limit, so it wanders. Fill in all four parts and the output becomes more predictable, and far easier to fix on the next round.

The drill works as a daily habit. Pick a real task, such as condensing a textbook chapter or drafting an email to a client. Write three prompts for it: a one-liner, a version with context and format, and a few-shot version with two examples. Keep the three answers side by side in one document and mark what changed. For multi-step problems like arithmetic or logic puzzles, add a chain-of-thought instruction that asks the model to show each step, then check every step yourself.

A weak prompt is almost always missing one of four parts: context, instruction, format or examples.

Hallucination and Bias: The Habit of Checking Model Output

A large language model builds sentences from patterns in its training data. That is why it can produce quotes, figures or book titles that sound convincing and do not exist. This is called hallucination. Bias comes from a different place: lopsided training data pushes the model toward a one-sided picture of certain jobs, regions or groups of people.

Both are hard for beginners to spot because a wrong answer arrives in exactly the same confident tone as a right one. Anyone using AI for homework, office reports or thesis research needs a checking habit from week one, before a copy-and-paste habit has the chance to form.

Here is how to build it. Whenever the model states something you can verify (a year, a name, a number, a citation), look it up in an official source and log it in a small table with columns for claim, source and status. After two weeks a pattern emerges: which kinds of question tend to go wrong and which are fairly safe. For bias, ask the same question twice while changing a single attribute of a person in the prompt, such as their home region or gender, and see whether the tone of the answer shifts.

The habit is in place when you flag checkable claims without thinking about it and always reread model output before it goes into your own work.

Treat every number, name and citation from a model as a claim to verify against an official source before you use it.

Python in Google Colab: Lists, Loops, Functions, then DataFrames

Google Colab runs Python straight from the browser with nothing to install. For someone who has never coded, that removes the biggest day-one obstacle: installing Python, sorting out paths and getting libraries to load. A notebook mixes code cells with text cells, so your explanations and experiments live next to each other.

A gentle sequence starts with variables and data types, moves to lists and dictionaries, then for loops, if statements and functions. Only after that come the libraries: NumPy for numbers, pandas for tables, and Matplotlib or Seaborn for charts. Many beginners stall on error messages such as IndentationError, KeyError or TypeError. Reading the last line of a traceback until you understand the cause is a skill in its own right, and it deserves deliberate practice.

Practice lands best on data you already know: a list of your test marks, a month of spending, a shop's sales log. Load the CSV with pandas, show the first five rows, drop empty rows, group with groupby, then draw one bar chart. Repeat that routine on two or three different datasets until the order feels automatic.

Your Python base is solid enough when you can write a small 20 to 50 line program without copying an example and can fix common errors by reading the message yourself.

Run the load, clean, group and plot routine on data you know until your hands remember the order.

Vectors and Matrices in NumPy: The Linear Algebra Models Use

To a model, one row of data is a vector: a list of numbers such as height, weight and age. A whole dataset is a matrix, with examples as rows and features as columns. Most of what a model does comes down to multiplying that matrix by a set of weights, adding a bias and passing the result to the next function. Once that clicks, the formulas in the scikit-learn and TensorFlow docs become much easier to follow.

Notation is usually the first hurdle. Transpose symbols, subscripts and summation signs look foreign when you only meet them in a textbook. The second hurdle is array size: a shape mismatch error appears when the column count of the first matrix differs from the row count of the second, and it stops many learners cold because they cannot see why.

The fix is to translate each idea into a few lines of NumPy. Make two vectors, compute their dot product with np.dot and check it against a hand calculation. Build a 3 by 2 and a 2 by 4 matrix, multiply them and inspect the .shape of the result. Try a transpose, normalise a vector and compute the Euclidean distance between two points. Whenever a shape error shows up, write both array sizes on paper before touching the code.

You have this skill when you can predict the shape of a matrix product before running the cell.

Write down the shape of each array before you multiply; that small habit heads off most shape errors.

Mean, Spread and Correlation: Reading Data Before You Train

Basic statistics is how you get to know a dataset before a model touches it. Mean and median describe the middle, standard deviation tells you how widely values spread, and correlation shows which columns move together. Basic probability prepares you for classification output, which often comes as the likelihood that an example belongs to a given class.

Beginners often skip this stage and go straight to training. Data problems then surface late: a column full of extreme values, classes of very different sizes, two features that carry almost the same information. The model still runs and still prints numbers, which is exactly why these mistakes slip through unnoticed.

The recommended drill is a short exploration every time you open a new dataset. Run describe() in pandas, plot a histogram for each numeric column, count examples per class with value_counts() and draw a correlation heatmap with Seaborn. Write three sentences of findings in a text cell before writing any model code. Compare mean and median on the same column too; a large gap points to extreme values worth investigating.

The skill is there when you can describe a dataset in a few plain sentences before choosing an algorithm for it.

Before training, write three findings about the data: its spread, its class balance and which columns correlate.

Supervised and Unsupervised Learning: Matching the Algorithm to the Problem

Supervised learning uses labelled data: every example comes with a correct answer, and the model learns to map features to that answer. When the answer is a category, such as spam or legitimate mail, the task is classification. When it is a number, such as a house price, the task is regression. Unsupervised learning works without labels and finds structure on its own, for example customer groups with K-means or a compressed view of many features with PCA.

The difficulty for beginners lies in the order of thinking. Many pick an algorithm first because they have heard its name, then hunt for a problem to fit it. It is easier to stay in control by starting with three questions: what are you trying to predict, does the data have labels, and is the answer a category or a number? Those answers alone narrow the field to a handful of algorithms.

For practice, list ten everyday problems, such as predicting an exam pass from study hours, grouping songs by tempo and length, or estimating next month's electricity bill. Label each one as classification, regression or clustering, then pair it with a starting algorithm: logistic regression, linear regression, a decision tree, a random forest or K-means. Supervised learning comes first in the learning order because its feedback is clear and progress is easy to measure.

Ask what you are predicting and whether the data is labelled; the choice of algorithm follows from those answers.

train_test_split, Overfitting and Hyperparameters

A model tested on the same data it trained on will look brilliant, since it has already seen every answer. So the data is split at the very start with train_test_split in scikit-learn, for example 80 percent for training and 20 percent for testing (the function defaults to 75 and 25 percent). The test score gives a more honest view of how the model will handle data it has never met.

Overfitting happens when a model memorises quirks of the training data. The symptom is easy to recognise: a high training score with a test score well below it. A decision tree with unlimited depth is the textbook case. The opposite, underfitting, happens when a model is too simple and both scores stay low.

The most eye-opening drill is a one-parameter experiment. Train a decision tree with max_depth set to 1, 3, 5, 10 and unlimited, and record training and test scores in a table. Plot both on one line chart and watch for the point where the lines start to drift apart. Then try cross-validation with cross_val_score to see whether the score holds steady across different slices of the data. This also introduces hyperparameter tuning: searching for the best model settings without peeking at the test set.

You understand this once you always report training and test scores together and can explain what the gap between them means.

Report training and test scores side by side; a wide gap is the signature of overfitting.

The Confusion Matrix: Reading Accuracy, Precision and Recall

For binary classification, a confusion matrix is a two-by-two table covering four outcomes: true positives, false positives, true negatives and false negatives. Three key measures come out of it. Accuracy is the share of predictions that were right. Precision asks, of everything predicted positive, how much really was positive. Recall asks, of everything that really was positive, how much the model found.

Beginners often stop at accuracy. That breaks down on imbalanced data: if only 5 percent of emails are spam, a model that labels every email as legitimate scores 95 percent accuracy while catching zero spam. Precision and recall expose that situation, and the F1-score folds both into a single number.

Start the drill by filling in the four cells by hand from ten predictions written on paper, then compare your table with confusion_matrix and classification_report in scikit-learn. Next, move the model's decision threshold from 0.5 to 0.3 and 0.7 and watch precision and recall pull against each other. Talk through the context as well: in disease screening, low recall means missed cases; in a spam filter, low precision means important mail lands in the junk folder.

The skill is in place when you can pick the measure that matters most for a given problem and justify it in one sentence.

On imbalanced data, accuracy can mislead; always read precision and recall alongside the confusion matrix.

Your First Neural Network: Perceptrons, Backpropagation and One Framework

Deep learning is built from a simple unit called the perceptron: it sums inputs multiplied by weights, adds a bias and passes the total through an activation function: a step function in the classic perceptron, or ReLU and sigmoid in modern networks. Stack many of them in layers and you have a neural network. Backpropagation is how the network improves: the error at the output is measured, and its derivative flows backwards to nudge every weight a little through gradient descent.

This is where many learners hesitate, because calculus enters the picture. It is enough at first to understand derivatives and gradients as the direction and size of a change, since TensorFlow or PyTorch does the actual computation. The other sticking point is choosing a framework. Both are widely used; pick one and stay with it until it feels fluent, because the concepts carry over easily.

The usual first exercise is the MNIST handwritten digits dataset: a network with a single hidden layer, trained for a few epochs while you watch the loss curves for training and validation data. Change the number of neurons, the learning rate and the number of epochs one at a time and note what happens. After that, move to a CNN for images and try transfer learning with a pre-trained model, which can produce reasonable results from a small dataset.

The skill starts to settle when you can read a loss chart and explain why the validation line stopped falling.

Choose one framework, start with a small network on MNIST and change a single setting per experiment.

Embeddings, RAG and a Portfolio Project on GitHub

At the advanced level, learners work on top of language models that already exist. An embedding turns text into a vector, so sentences with similar meaning sit close together. RAG (retrieval-augmented generation) puts that to work: your own documents are split into chunks, turned into embeddings and stored, then the most relevant chunks are retrieved and handed to an LLM together with the user's question. The answer that comes back leans on those documents.

The hardest part at this stage is finishing something. Plenty of learners work through dozens of tutorials and never complete a single app. A healthier pattern is to choose one small, real problem, such as answering questions about your own course notes, summarising meeting minutes or classifying product reviews, and take it from raw data all the way to a working interface.

A tidy project holds a data exploration notebook, a training or API script, a simple Streamlit app and a README that explains the problem, the data, how to run it and where the model falls short. Keep it on GitHub with a commit history that shows the process. Test the app with deliberately tricky questions, record the answers that miss and write those findings into the README. Ethics belongs here too: keep personal data out of the repository and credit every data source.

A project counts as finished when someone else can run it using only the README.

One project carried from data to interface, with a clear README, teaches more than ten half-finished tutorials.

Reading Order

Your Reading Path Through the AI Guides

Begin with the roadmap article, since every later step in learning AI branches out from it.

How to Learn AI from Scratch: A 7-Step Beginner Roadmap
It maps all 7 steps from generative AI tools to deep learning, so learners can see where they stand today and what comes next.

Who It Suits

Who These AI Guides Are For

Secondary school students curious about how ChatGPT works who want to begin with AI literacy.
University students outside computing who want Python and machine learning for a thesis or research project.
Professionals in marketing, HR or finance looking to streamline everyday work with generative AI.
Adult learners moving into a data career who need a clear order for learning from scratch.
Web and app developers who want to wire an LLM into their product through an API and RAG.

How to Learn AI from Scratch: A 7-Step Beginner Roadmap

How to learn AI from scratch as a complete beginner: start with generative AI tools, build Python foundations, cover linear algebra and basic statistics, then practice with scikit-learn, TensorFlow, and PyTorch.

Read Guide

AI Questions

Common Questions About Learning AI

Should I start learning AI with prompts or go straight to Python?

For complete beginners the prompt route is the gentlest, since all it needs is a free account on a generative AI tool. After a week or two of seeing how a model answers and where it slips, Python is the natural next step. If you already know some programming, starting on the coding route is fine too; just keep practising the habit of checking model output alongside it.

How much maths does early machine learning actually use?

Two things to begin with: linear algebra for vectors and matrices, and basic statistics for means, spread, correlation and probability. Heavier calculus only starts to matter in deep learning, and it can be picked up along the way when the material calls for it. Understanding what derivatives and gradients mean is enough at first, because libraries handle the arithmetic. Maths sticks fastest when you learn it in parallel with NumPy code.

Which library is used to train a first machine learning model?

Most learners start with scikit-learn, whose consistent API and tidy documentation cover classification, regression and clustering. When the supervised learning workflow feels comfortable, they move on to TensorFlow or PyTorch to study neural networks. Small built-in datasets such as iris or digits keep the first experiments light, and they run comfortably in Google Colab with no GPU at all.

Is an ordinary laptop enough for learning AI and machine learning?

For most of the material, yes. Prompt engineering needs only a browser, and Python with scikit-learn runs smoothly on small datasets on a typical laptop. For deep learning that calls for a GPU, Google Colab offers GPU access in the browser, so you can train a network on MNIST or try transfer learning without buying special hardware. A stable internet connection and the habit of saving notebooks neatly matter more than raw computing power.

What is the difference between AI, machine learning and deep learning?

AI is the broad umbrella for systems that imitate human reasoning, rule-based systems included. Machine learning is the part of AI that learns patterns from data, through methods such as regression, decision trees and K-means. Deep learning is the part of machine learning that uses layered neural networks, and it underpins computer vision, NLP and the large language models behind ChatGPT, Claude and Gemini.

How can I tell whether a machine learning model is good enough?

Test it on a hold-out set separated at the start with train_test_split, then compare that score with the training score. A wide gap points to overfitting. For classification, read the confusion matrix together with precision and recall, especially when the classes are imbalanced. It also helps to compare against the simplest possible baseline, such as always guessing the most common class; a model that barely beats that guess has learned little from the data.