You almost certainly used artificial intelligence before breakfast today. When your phone unlocked by recognising your face, when your email quietly slid a junk message into the spam folder, when your maps app rerouted you around a jam, that was AI at work. So what is artificial intelligence once you set the sci-fi robots aside? It comes down to one down-to-earth idea: a computer handling a job we used to believe only a human mind could do. That is the working definition this whole series runs on, and it is enough to make sense of everything ahead, from your first line of Python to training real models.

“Artificial intelligence is the new electricity.”

Andrew Ng

Last Updated: July 2026 | Tested on: Python 3.14.6 | Difficulty: Beginner | Reading Time: 20 minutes

This lesson opens the AI half of the series and assumes zero Python. If you landed here first, welcome: you are in the right place. By the end, the four terms everyone mixes up, AI, machine learning, deep learning, and generative AI, will sit in one picture you can redraw from memory.

Think of this as the front door to everything AI and machine learning: we define the words clearly, run one tiny program to make the ideas concrete, walk through seventy years of history in a few minutes, and end with an honest look at what these tools can and cannot do in 2026. By the end you will know exactly where terms like ML, deep learning, and generative AI sit, and you will never mix them up again.

What Artificial Intelligence Actually Means

Ask ten engineers “what is artificial intelligence” and you will get ten different answers, so here is a homely way to think about it. Say a shopkeeper named Aditi teaches her new helper to spot ripe tomatoes: soft to the touch, deep red, a little heavy for their size. The helper is now doing a task that needed Aditi’s judgement a week ago. Artificial intelligence is the same trick, done by software. We hand a machine a task that normally needs a person, and it does a passable job on its own.

The important word is task. AI is not one thing, it is a label we put on any program that handles a slice of what we call thinking: recognising, predicting, ranking, translating, generating. A calculator is not AI, because arithmetic was never seen as uniquely human. A program that reads a handwritten pincode off an envelope is AI, because reading messy handwriting used to be a human-only skill. The line moves over time. Chess felt like the summit of intelligence until a computer won, and then it just felt like chess. This shifting goalpost even has a nickname among researchers: the moment a hard problem gets solved, people stop calling it AI.

AI, ML, Deep Learning, and GenAI: The Nesting Dolls

The single biggest source of confusion is that four terms get used as if they mean the same thing. They do not. They nest inside each other like a set of Russian dolls: the biggest doll holds a smaller one, which holds a smaller one still, down to the tiny doll right at the centre. Every generative AI model is a deep learning model. Every deep learning model is machine learning. All of it is artificial intelligence. It does not run the other way: plenty of AI is not machine learning at all.

Read the diagram from the outside in. Artificial Intelligence is the biggest doll: any machine doing human-like tasks, including old-school systems that follow rules a person wrote by hand, like a chess engine or a GPS route finder. Machine Learning is a doll inside it: instead of a human writing the rules, the system learns the rules from examples. Deep Learning sits inside ML: it is machine learning built on many-layered neural networks, which are loosely inspired by how brain cells connect. Generative AI is the smallest doll: deep learning models that do not just judge or predict, they produce new text, images, and audio. The chatbots and image tools everyone talks about live in that innermost doll.

Keep this picture in your head and the news suddenly makes sense. When someone says “we added AI to our app,” they might mean a simple rule engine in the outer doll or a giant language model at the very centre. When a job ad asks for machine learning, it usually is not asking for chatbots. The words are not interchangeable, and knowing which doll someone means is half of understanding any AI conversation.

Rules vs Learning: Two Ways to Filter Spam

The jump from “AI” to “machine learning” hinges on one word: learning. That word gets thrown around loosely, so let us make it concrete with the oldest practical AI problem there is, filtering spam. We will solve it twice. First the old way, where a human writes every rule. Then the learning way, where the program works out the rules itself from examples. Both are real, runnable Python you can paste and run on Python 3.14.6 with nothing installed.

The rules approach is exactly what it sounds like. You, the human, sit down and list the words that scream spam. If a message contains any of them, flag it. This is classic outer-doll AI: smart-looking behaviour, zero learning.

📄 spam_rules.py: a human writes every decision by hand

# Rules-based spam filter: a human writes every decision by hand
SPAM_WORDS = {"free", "win", "won", "prize", "click", "cash", "loan", "claim"}

def is_spam_rules(message):
    words = message.lower().split()
    hits = [w for w in words if w in SPAM_WORDS]
    return len(hits) > 0, hits

tests = [
    "win a free prize now click here",
    "are we still meeting for lunch today",
    "our team lunch is on the house this friday",
    "reminder: your invoice payment is overdue",
]

for msg in tests:
    flag, hits = is_spam_rules(msg)
    label = "SPAM" if flag else "ham "
    print(f"[{label}] {msg}")
    if hits:
        print(f"         matched words: {hits}")

▶ Output

[SPAM] win a free prize now click here
         matched words: ['win', 'free', 'prize', 'click']
[ham ] are we still meeting for lunch today
[ham ] our team lunch is on the house this friday
[ham ] reminder: your invoice payment is overdue

What happened here: The obvious spam gets caught because it is stuffed with words from our list. The two normal notes pass. But look at the last line: “reminder: your invoice payment is overdue” is a classic phishing hook, and our filter waves it straight through, because we never thought to add “invoice” or “overdue” to the list. That is the fatal weakness of hand-written rules. They only catch what the author already imagined. Spammers change their wording every week, and a human cannot rewrite the list fast enough. This is precisely the wall that pushed the field toward learning.

Now the learning version. We do not write a single spam rule. Instead we hand the program a small pile of messages that are already labelled spam or not-spam, and it figures out on its own which words matter and by how much. The technique is called logistic regression, and here it is from scratch in pure Python so nothing is hidden. You will meet it properly later in the machine learning part, but you can watch it learn right now.

📄 spam_learn.py: the program learns the rules from labelled examples

import math

# Labeled examples. 1 = spam, 0 = not spam. Nobody writes rules here.
# The model reads these and figures out for itself which words matter.
train = [
    ("win a free prize claim now", 1),
    ("free money click here to win cash", 1),
    ("you won a free gift claim your reward", 1),
    ("get a cheap loan cash fast click now", 1),
    ("final notice your invoice payment is overdue", 1),
    ("act now limited offer just for you", 1),
    ("are we still meeting for lunch today", 0),
    ("can you send me the project report", 0),
    ("lunch at the new cafe sounds good", 0),
    ("the report is due on friday", 0),
    ("thanks for your help with the slides", 0),
    ("see you at the team standup tomorrow", 0),
]

# Build the vocabulary from the training text alone
vocab = sorted({w for msg, _ in train for w in msg.split()})
index = {w: i for i, w in enumerate(vocab)}

def features(message):
    vec = [0.0] * len(vocab)
    for w in message.lower().split():
        if w in index:
            vec[index[w]] = 1.0
    return vec

def sigmoid(z):
    return 1.0 / (1.0 + math.exp(-z))

# Train a logistic regression by gradient descent (pure Python, no libraries)
weights = [0.0] * len(vocab)
bias = 0.0
lr = 0.5
for epoch in range(400):
    for msg, label in train:
        x = features(msg)
        pred = sigmoid(sum(w * xi for w, xi in zip(weights, x)) + bias)
        error = pred - label
        for i in range(len(weights)):
            weights[i] -= lr * error * x[i]
        bias -= lr * error

# The model has now LEARNED which words signal spam. Show the top ones.
ranked = sorted(zip(vocab, weights), key=lambda p: p[1], reverse=True)
print("Top words the model learned to distrust (weight):")
for word, w in ranked[:6]:
    print(f"   {word:<10} {w:+.2f}")

def spam_score(message):
    x = features(message)
    return sigmoid(sum(w * xi for w, xi in zip(weights, x)) + bias)

print("\nScoring new messages (probability it is spam):")
tests = [
    "win a free prize now click here",
    "are we still meeting for lunch today",
    "your invoice payment is overdue please act now",
]
for msg in tests:
    p = spam_score(msg)
    verdict = "SPAM" if p >= 0.5 else "ham "
    print(f"   [{verdict}] {p:5.1%}  {msg}")

▶ Output

Top words the model learned to distrust (weight):
   now        +2.24
   free       +1.85
   a          +1.61
   act        +1.26
   just       +1.26
   limited    +1.26

Scoring new messages (probability it is spam):
   [SPAM] 100.0%  win a free prize now click here
   [ham ]   0.1%  are we still meeting for lunch today
   [SPAM] 100.0%  your invoice payment is overdue please act now

What happened here: Notice what we did not do: we never told the program that “free” or “now” are suspicious. It read twelve labelled messages and worked that out itself, which is what the learned weights show. Higher weight means more spammy. And here is the payoff, the very message the rule filter missed, the invoice reminder, now scores as spam, because the model learned from the one training example that used that style.

That is learning in one word: the logic comes from the data, not from a human typing rules. One honest caveat you can see in the output: the plain word “a” got a high weight too, purely because it happened to appear in several spam samples. With only twelve examples the model picks up silly coincidences like that. Feed it thousands of real emails and those flukes wash out. That need for lots of data is one of the biggest trade-offs of the learning approach, and something you will manage constantly in real projects.

Seventy Years of AI in Ten Minutes

People were arguing about what is artificial intelligence before the internet existed, and the field has boomed and busted more than once. Knowing the arc helps you tell today’s genuine progress from recycled hype.

The 1950s, the dream begins. In 1950 Alan Turing asked whether machines could think and proposed the imitation game, now called the Turing test. In 1956 a summer workshop at Dartmouth College gave the field its name, artificial intelligence, and a wave of optimism. Early programs proved maths theorems and played checkers, and researchers cheerfully predicted human-level machines within a generation.

The 1960s to 1980s, symbolic AI and expert systems. For decades the dominant idea was to encode human knowledge as explicit rules, exactly like our first spam filter but much larger. These expert systems captured a specialist’s know-how as thousands of if-then rules and did real work in medicine and finance. But they were brittle and hugely expensive to maintain, since every new case meant a human writing more rules. When the promises outran the results, funding dried up twice, in periods people now call the AI winters. The lesson stuck: hand-written knowledge does not scale.

The 1990s to 2000s, learning from data. The field quietly changed strategy. Instead of writing rules, feed the computer examples and let it find the patterns, the approach we just saw. Cheaper storage and faster chips made this practical. In 1997 IBM’s Deep Blue beat world champion Garry Kasparov at chess, and by the 2000s machine learning was silently running spam filters, search rankings, and product recommendations for millions of people.

2012, deep learning breaks through. This is the first date to remember. A neural network called AlexNet crushed the field at a large image-recognition contest, cutting the error rate so sharply that the whole industry pivoted overnight. Two ingredients that had been missing finally arrived together: mountains of digital data and graphics chips (GPUs) fast enough to train big networks. Deep learning went from a backwater to the main road.

2017, the transformer arrives. The second date. A Google research paper titled “Attention Is All You Need” introduced the transformer, a network design that reads a whole sentence at once and weighs how each word relates to the others. It trained faster and scaled to enormous sizes far better than anything before it. Almost every large model you have heard of since is built on this one idea.

2022 onward, the LLM era. The third date. Late in 2022 a conversational model reached ordinary people, and suddenly anyone could type a question and get a fluent answer. That was the moment generative AI, the innermost doll, went mainstream. Large language models now draft emails, write code, and summarise documents for hundreds of millions of users. We are still early in this chapter, and it is the reason you are probably reading this post.

What AI Can and Cannot Do in 2026

Honesty is the most useful thing a beginner can carry. AI in 2026 is genuinely powerful and genuinely limited, and the gap between what a demo suggests and what a system reliably delivers is where most disappointment lives. Here is the fair picture.

What it does well today: recognising patterns in images, audio, and text; translating between languages; drafting and summarising writing; generating code, pictures, and speech; ranking and recommending; and answering questions over a body of documents. If a task is common, has lots of examples, and tolerates the occasional mistake, AI is often excellent at it.

Where it still struggles: being reliably correct on facts (language models can state a wrong answer with total confidence, which people call a hallucination); genuine reasoning over many careful steps; anything needing common sense about the physical world; and tasks where being wrong is expensive, like medical or legal decisions without a human checking. It also knows nothing beyond its training data unless you connect it to live tools, and it can quietly absorb the biases in that data.

To sort real progress from marketing, keep a small hype detector handy. Ask these four questions whenever you read an AI claim:

• What exactly does it do, in one sentence? If the pitch cannot name a concrete task, be skeptical.
• How often is it wrong, and what happens when it is? A demo shows the wins. Ask about the failures.
• Was it tested on data it had never seen? Impressive numbers on the training data mean little.
• Is a human still in the loop for the risky calls? The honest products keep one there.

The 2026 AI Job Landscape

“Working in AI” is not one job, it is a family of them, and they need different skills. Here are the main roles as they look at the time of writing, and which part of this series builds toward each. You do not need all of them. Pick the row that excites you and follow its trail.

One reassuring note for beginners: every role in that table rests on the same foundation, comfortable Python plus a clear grasp of data. That is exactly what the earlier parts of this series give you, and it is why an AI career and a Python career are really the same journey.

Common Misconceptions About AI

• “AI and machine learning are the same thing.” No. ML is one doll inside AI. A rule-based system with no learning is still AI. Keep the nesting dolls in mind and you will always place a tool correctly.
• “AI understands what it says.” A language model predicts likely next words from patterns in its training data. Its answers can be fluent and useful, but there is no understanding or intent behind them, which is exactly why it can be confidently wrong.
• “More data always means a better model.” Only if the data is relevant and clean. Aviraj can feed a model a million junk records and get a worse result than a colleague who used ten thousand good ones. Quality beats raw quantity.
• “You need a maths PhD to start.” Not to begin. You need Python, curiosity, and the willingness to run code and read the output honestly. The deep maths helps later, and this series builds it up gently when you need it.
• “AI is about to replace all programmers.” At the time of writing it is a strong assistant that speeds up the routine parts and still needs a human to steer, review, and catch its mistakes. It changes the job more than it deletes it.

How to Think Clearly About AI

• Always ask which doll. When you hear “AI,” pin down whether someone means hand-written rules, machine learning, deep learning, or a generative model. The word alone tells you little.
• Prefer learning when the rules keep changing. If a human can write a short, stable set of rules, do that, it is simpler and easier to debug. Reach for machine learning when the patterns are messy or shifting, like spam.
• Judge a model on data it has never seen. Performance on the training examples is easy to fake. Real quality shows up on fresh data, a habit you will use in every ML post ahead.
• Keep a human on the risky decisions. Use AI to draft, suggest, and speed things up, and keep a person accountable for anything that really matters.
• Learn the fundamentals, not just the tool of the month. Model names change every year. The ideas in this post, and the maths and code in the parts that follow, do not.

Conclusion

So, what is artificial intelligence? It is any machine doing a task we used to reserve for human minds, and the famous flavours everyone talks about, machine learning, deep learning, and generative AI, are simply smaller and smaller dolls nested inside that idea. You saw the difference between hand-written rules and real learning in a program small enough to read in one sitting, you have the seventy-year arc that explains why 2012, 2017, and 2022 mattered, and you have an honest sense of what these tools can and cannot do. That mental model will outlast every model name in the headlines.

From here the series gets hands-on. Next you will build the maths and code intuition behind machine learning, then train real models, then work up to deep learning and the generative AI everyone is talking about. The full series map, beginner to AI engineer, is on the Python + AI/ML tutorial series home.

Frequently Asked Questions

Interview Questions on Artificial Intelligence

Scenario questions, not trivia: this is the form this topic takes in a real interview.

Q: In one sentence, what is artificial intelligence?

Artificial intelligence is any computer system that performs tasks we normally associate with human intelligence, such as recognising, predicting, translating, or generating. It is a broad umbrella that includes both rule-based systems written by hand and systems that learn from data. The key point in an interview is to show you know AI is wider than machine learning, not a synonym for it.

Q: How do AI, machine learning, deep learning, and generative AI relate?

They are nested subsets. AI is the largest set. Machine learning is a subset of AI where the system learns rules from data. Deep learning is a subset of machine learning that uses many-layered neural networks. Generative AI is a subset of deep learning that produces new content like text and images. Every generative model is deep learning, every deep learning model is ML, and all of it is AI, but not the reverse.

Q: What is the core difference between a rule-based system and a machine learning system?

In a rule-based system a human writes the logic explicitly, for example a fixed list of spam words. In a machine learning system the logic is learned from labelled examples, so the model discovers which features matter and by how much. Rules are simple and easy to debug but brittle and hard to keep current. Learning adapts to new patterns but needs data, compute, and careful evaluation.

Q: Why did deep learning take off around 2012 and not earlier?

The core neural network ideas existed for decades, but two practical ingredients were missing: enough labelled data and enough computing power. By 2012 the internet had produced huge labelled image datasets, and GPUs made training large networks feasible. AlexNet’s win at a major image contest that year proved the approach and triggered the shift. It is a good example of methods waiting on data and hardware to catch up.

Q: What is a hallucination in a language model, and why does it happen?

A hallucination is when a language model produces a confident statement that is false or made up. It happens because the model is trained to predict plausible next words from patterns, not to look up verified facts, so a fluent but wrong answer can look just as likely as a correct one. The practical fixes are grounding it in trusted sources, letting it use tools to check facts, and keeping a human reviewer on anything important.

Q: Scenario: a manager named Anvi says a demo model scored 99 percent accuracy and wants to ship it tomorrow. What do you ask?

First, was the 99 percent measured on data the model had never seen, or on its training data? High training accuracy proves little. Second, what does the errors breakdown look like, since 99 percent overall can hide total failure on a rare but important case. Third, is the data balanced, because 99 percent is trivial if 99 percent of examples share one label. And finally, what happens when it is wrong in production, and is a human in the loop for the costly mistakes. Those questions separate a real result from a demo number.

Want more? the official Python documentation documents everything this post could not fit.

Related Posts

Previous: Data Science: End-to-End Project, Raw Data to Insights

Next: What is an AI Model? Weights, Training, and Inference

Series Home: Python + AI/ML Tutorial Series