Module 1: What Is AI Really?

3. A Brief History of AI: From Turing to ChatGPT

Description

In this lesson you'll place artificial intelligence in time: from the founding ideas to the current LLM boom. It isn't an exhaustive chronology; it's a thread that lets you understand why today we talk so much about "language models", "Transformers" and "AI APIs", and why there were earlier eras of deep skepticism (the AI "winters").

Knowing this history helps you not believe that "it all started with ChatGPT" and to understand that recent advances rest on decades of research, data and computing power. It also gives you judgment for reading news and statements: many of the questions asked today (can a machine think? understand? replace a human?) were already being posed in the 50s; what changed is that we now have systems that, in bounded domains, outperform humans at specific tasks.

Why this history matters for your work

Before getting into dates and milestones, it's worth being clear about what knowing this history is good for if your goal is to work with AI (for example as an AI Engineer):

Avoiding wrong expectations. Someone who believes "it all started with ChatGPT" may expect models to do things they don't do (infinite memory, zero errors, AGI). History shows that advances are incremental and that the "leaps" rest on decades of research, data and compute.
Interpreting news and statements. When someone says "we're close to AGI" or "this model changes everything", history gives you context: there have been cycles of optimism and disillusionment; the technical foundation today is more solid than in the 70s or 80s, but short-term predictions are still risky.
Understanding your role. The work of an AI Engineer today (integrating models via APIs, RAG, agents) is the direct result of that evolution: you don't program rules by hand as in the 80s, nor do you train from scratch in most cases; you use pre-trained models that learned from data. History explains why the center of gravity is there.
Reasoning about limits. Models have limits (hallucinations, finite context, cost); history helps you see that those limits aren't "bugs" but consequences of how they work (learning from data, architectures, scale). Designing systems that assume those limits is part of the job.

Origins: Turing and the question "Can a machine think?"

1940s-50s. Alan Turing wasn't only a key mathematician in computing (the Turing machine, codebreaking in World War II); in 1950 he published Computing Machinery and Intelligence, where he posed the question: Can machines think? Instead of getting tangled in definitions of "thinking" or "consciousness", he proposed an operational test: if a human, conversing in writing with something they can't see, cannot tell whether they're talking to a person or a machine, then it makes sense to say the machine "thinks" in that sense (today we know it as the Turing Test).

The idea wasn't to prove that machines are conscious, but to change the question from philosophy to one that could be measured: can the machine do X so well that a human doesn't notice the difference? That opened the door to concrete goals: games, reasoning, language, vision. Turing also anticipated objections (what if the machine is only simulating? what if it has no emotions?) and answered them with arguments that remain relevant today: the question isn't "does it have consciousness?" but "does it behave in a way we can't distinguish from a human at task X?".

In parallel, in 1956 the Dartmouth Workshop was held, where the term "Artificial Intelligence" was coined and the field was defined as the study of how to make machines perform tasks that, if a human did them, we'd say require intelligence. The organizers (among them John McCarthy, Marvin Minsky, Claude Shannon) were optimistic: they expected significant advances within a few years. That mix of ambition and clear definition of the field marked the birth of AI as a discipline. The workshop lasted several weeks and brought together researchers who then led the field for decades; many of the ideas discussed (reasoning, language, learning) are still central today.

Why it matters: The question wasn't only philosophical. It opened the door to defining concrete goals (games, reasoning, language) and to measuring progress. Today we still talk about "can the machine do X?" instead of "is it conscious?". For an AI Engineer, that translates into metrics: precision, recall, latency, user satisfaction; not into debates about consciousness.

Early programs and the first "winter"

1950s-70s. Programs were built that played checkers (Samuel, 1959), proved theorems (Logic Theorist, 1956) or solved logic problems in very narrow domains. The feeling was one of rapid progress; very optimistic predictions were made. In 1965, Herbert Simon said that "within 20 years machines will be capable of doing any work a human can do"; in 1970, Marvin Minsky claimed that "in three to eight years we'll have a machine with the general intelligence of an average human being". Those promises weren't kept.

Problems: The systems worked in very limited domains; they didn't generalize. There was no massive data or computing power to learn from experience. The methods (tree search, symbolic rules) didn't scale to real-world problems. When funding (especially in the US and the UK) and interest dropped, the first AI winter arrived (mid-70s): fewer funds, lower expectations, more skepticism. Reports such as Lighthill's (1973) in the UK criticized AI for not delivering on its promises and contributed to cuts.

Analogy: It's like promising that in five years you'll have a flying car in every garage: the idea is seductive, but the gap between the prototype and reality is enormous. The AI of the 60s had impressive prototypes in small domains; the real world was far more complex.

Lesson: Over-promising and under-delivering breeds distrust. Today the field is more cautious with short-term predictions (though hype still exists); when you hear "AGI in two years" or "this changes everything", remember that history repeats itself.

Expert systems and the second winter

1980s. Expert systems emerged: programs that encoded the knowledge of human experts into rules (e.g. medical diagnosis like MYCIN, equipment configuration like DEC's XCON). The idea was to capture an expert's "know-how" in a set of rules of the form "if X and Y, then Z". They were commercially successful in niches: companies paid a lot for systems that helped with very specific tasks.

Problems: They were brittle. The rules were hard to maintain: each new exception or change in the domain required a human to write more rules. They didn't "learn" on their own; all the knowledge came from experts who poured it in by hand. Outside their domain, they failed without warning. When expectations once again outran reality (more promises of "AI that does everything") and investment shrank, the second AI winter arrived (late 80s and early 90s): once again, fewer funds and more skepticism.

Why it matters for an AI Engineer: Today you don't build expert systems with thousands of hand-written rules; you build pipelines that use models that learned from data. The lesson of the 80s is that scaling knowledge by hand isn't sustainable. When you design a system (RAG, classifier, agent), think about which part "learns" from data and which part is explicit rules; rules are useful for business logic, but domain knowledge usually comes better from data.

Lesson: Systems based only on rules have a ceiling; scaling knowledge by hand isn't sustainable. That drove interest in systems that learn from data (ML).

Machine Learning and data

1990s and 2000s. The focus shifted from "programming rules" to "learning from data". Classic ML algorithms became popular: decision trees, small neural networks, support vector machines (SVM), probabilistic models (Naive Bayes, mixture models). Practical applications started becoming visible: spam filters (they learn from what you mark as spam), recommendations (Netflix, Amazon learn from clicks and ratings), voice and image recognition in bounded domains. The central idea was: instead of a human writing rules ("if the word X appears, it's spam"), the system learns patterns from labeled examples or from behavior (clicks, ratings).

Key factors: More digital data (internet, mobile phones, sensors), more computing power (Moore's law), and public competitions (e.g. ImageNet, from 2010) that allowed methods to be compared objectively. ImageNet is a dataset of millions of images labeled across thousands of categories; for years, teams around the world competed to lower the classification error. That generated shared standards and metrics: it was no longer "my method vs yours" on different datasets, but on the same benchmark. That culture of benchmarks and competitions later carried over to language (GLUE, SuperGLUE, etc.) and is still central today.

Analogy: It's the shift from "writing every recipe by hand" to "letting the kitchen learn from thousands of dishes already made". Expert systems were fixed recipes; ML is learning patterns from examples.

Why it matters: This is where the idea that data is the fuel of practical AI takes hold. Without data (and without compute), progress stalls. It's the same idea that sustains LLMs today: enormous models trained on massive amounts of text (and other data). When you design a system (RAG, classifier, agent), ask yourself where the data feeding the model comes from: public data? your own data? fine-tuning or just a prompt?

Deep Learning and the current boom

From ~2012 onward. In 2012, a team from the University of Toronto (Krizhevsky, Sutskever, Hinton) won the ImageNet competition with a deep convolutional neural network (AlexNet), dramatically reducing the classification error compared with previous methods. That moment is usually cited as the start of the Deep Learning boom: networks with many layers that learn hierarchical representations of the data.

In the following years, deep networks were applied to speech (voice recognition on phones and assistants), language (embeddings, machine translation) and games (AlphaGo, 2016). It stopped being just research: real products (voice assistants, translation, recommendations, facial recognition) started using Deep Learning.

Factors: Large-scale data (internet, mobile phones, millions of images and texts), GPUs to train large networks (training on CPU was impractical for deep networks), and new architectures (e.g. attention, which later gave rise to Transformers) that handled sequences (text, audio) far better than classic recurrent networks.

Why it matters for an AI Engineer: Almost everything you integrate today (language, vision, speech APIs) rests on Deep Learning models. Understanding that "Deep Learning" isn't magic but networks that learn from data helps you reason about limits (they need data, compute, and they have biases if the data does) and about what to expect from a model.

Why it matters in the history: It's the direct bridge to LLMs. Large language models (GPT, BERT, etc.) are deep networks trained on massive amounts of text; without the Deep Learning boom they wouldn't exist as we know them today.

Transformers and the era of LLMs

2017 onward. The paper "Attention Is All You Need" (Vaswani et al., 2017) introduced the Transformer architecture: networks that use "attention" to relate each element of a sequence to all the others, without depending on step-by-step recurrence. That made it possible to train much larger language models, and in parallel (better use of GPUs). Out of that came BERT (2018, oriented toward comprehension and classification), GPT-2 (2019), GPT-3 (2020), and later ChatGPT (2022) and the explosion of LLM-based products (Claude, Gemini, Llama, Mistral, etc.).

Qualitative change: From "models that classify or predict" (is it spam? which category?) to "models that generate text (and later images, audio, code)" and are consumed via APIs. That's what people usually call "Generative AI" or "the ChatGPT era". It's not that there was no generation before; it's that the quality and the scale moved to another level, and access (APIs, consumer products) meant anyone could use a large language model without training anything.

Why it matters for an AI Engineer: Almost all practical work today revolves around consuming or integrating these models: choosing a provider (OpenAI, Anthropic, Google, Meta, Mistral…), designing prompts, connecting to your own knowledge (RAG), evaluating responses, handling fallbacks. The history you've just read leads to that: not to "programming rules" nor to "training from scratch in your garage", but to using models that learned from data and exposing them as services.

The Transformer architecture changed your potential role: before (expert systems, rules) the job was encoding knowledge by hand; in the classic ML era it was preparing data and features; today it's choosing the right model (OpenAI, Anthropic, open source), designing the prompt, connecting to documentation (RAG), and evaluating that the responses are correct. That is AI Engineering: integration, not research or training from scratch. That's why when you read "AI Engineer" in job postings, the focus is on APIs, frameworks (LangChain, LlamaIndex), and system design (agents, RAG, evaluation), not on training Transformers from scratch.

The "winters" in a table

Period	What happened	Why it cooled down
First winter (~1974)	Promises of "general AI" unfulfilled; very limited systems	Sky-high expectations, narrow results, less funding
Second winter (~1987-93)	Expert systems expensive to maintain; they didn't scale	Limits of hand-written rules; hype once again above reality

Pattern: Cycles of optimism → excessive promises → disillusionment → less investment → then new approaches (data, Deep Learning) that raise expectations again. Today we're at a peak of expectations; history suggests being cautious with 5-10 year predictions, but also that the technical foundation (data, compute, architectures) is more solid than in the 70s or 80s.

Condensed timeline

To lock in the ideas, here's a timeline with key milestones (not exhaustive):

Year (approx.)	Milestone	What changed
1950	Turing Test	Operational question: can the machine do X without a human noticing the difference?
1956	Dartmouth Workshop	"Artificial Intelligence" is coined; the field is born as a discipline.
1956-59	Logic Theorist, game-playing programs	First programs that "reason" or play in very narrow domains.
~1974	First AI winter	Less funding; unfulfilled promises; Lighthill report.
1980s	Expert systems (MYCIN, XCON)	Knowledge encoded in rules; success in niches; expensive to maintain.
~1987-93	Second AI winter	Expectations once again above reality; less investment.
1990s-2000s	Classic ML (spam, recommendations)	Focus on "learning from data"; more digital data and compute.
2010	ImageNet and competitions	Standards for comparing vision methods (and later other domains).
2012	AlexNet wins ImageNet	Start of the Deep Learning boom; deep networks in vision.
2016	AlphaGo beats a Go champion	Deep Learning in games; media impact.
2017	"Attention Is All You Need"	The Transformer architecture is born; the basis of today's LLMs.
2018-20	BERT, GPT-2, GPT-3	Large language models; pre-training at scale.
2022	ChatGPT and LLM products	Mass access to text generation via chat and APIs.
2023-26	Claude, Gemini, Llama, Mistral…	Ecosystem of models and APIs; RAG, agents, multimodality.

You don't need to memorize dates; use this table as a reference when you want to place a milestone or explain to someone "where what you use today comes from".

Common mistakes when using this history

1. "It all started with ChatGPT"

Mistake: Treating AI as if it were born in 2022.
Reality: AI has roots in the 50s (Turing, Dartmouth); LLMs are the result of decades of research in ML, Deep Learning and architectures (Transformers). ChatGPT is a milestone of product and access, not the origin of the field.

2. "The winters mean AI is useless"

Mistake: Interpreting the winters as "AI failed".
Reality: The winters were periods of less funding and lower expectations, not of zero progress. Research continued; what dropped was hype and investment. Afterward came ML, Deep Learning and LLMs.

3. "Expert systems were useless"

Mistake: Dismissing expert systems for not scaling.
Reality: They were commercially successful in niches (diagnosis, configuration) and showed that encoding knowledge in rules has a ceiling. That drove the shift toward "learning from data", which is what we use today.

4. "Deep Learning appeared out of nowhere in 2012"

Mistake: Believing neural networks were invented in 2012.
Reality: Neural networks had existed since the 50s-60s; what changed in 2012 was the combination of data at scale, GPUs and architectures that made it possible to train deep networks successfully. It was a turning point, not a new invention.

Frequently asked questions

Why is "Attention Is All You Need" talked about so much?
Because that paper (2017) introduced the Transformer architecture, which is the basis of almost all of today's LLMs (GPT, BERT, Claude, etc.). It changed the way sequences (text, audio) are handled and made it possible to train much larger models.

Were there more than two winters?
Yes; periods of lower investment or expectations are sometimes mentioned at other moments. The two most cited are the one in the mid-70s and the one in the late 80s / early 90s.

What does ImageNet have to do with LLMs?
ImageNet is an image dataset; the associated competition drove Deep Learning in vision. The same ideas (deep networks, training at scale) later carried over to language; LLMs are deep networks trained on text instead of images.

Why does history matter for an AI Engineer?
Because your job (integrating models via APIs, RAG, agents) is the result of that evolution: you don't program rules by hand or train from scratch in most cases; you use pre-trained models that learned from data. Understanding where they come from helps you reason about limits and expectations.

What happened between expert systems (1980s) and the Deep Learning boom (2012)?
In the 90s and early 2000s, classic ML (decision trees, SVMs, small neural networks) started working in bounded domains: spam, recommendations, classification. It wasn't "sexy" like expert systems or like LLMs today, but it was practical. Deep Learning took off once there was enough data, GPUs and architectures (e.g. convolutional networks for images).

When is the "ChatGPT era" or "GenAI" considered to have started?
ChatGPT launched in November 2022, but the technology (Transformers, large language models) had existed since 2017-2020 (GPT-3, BERT). What changed in 2022 was mass access via a consumer product: millions of people started using LLMs directly, not just researchers or companies. That accelerated adoption and the public debate about AI.

From history to daily work: what it means for an AI Engineer

The history you've just read isn't only general knowledge; it has direct consequences for how you work:

You don't program rules by hand for domain knowledge. Expert systems showed that scaling knowledge in rules isn't sustainable. Today domain knowledge comes from data (pre-trained models, RAG, fine-tuning). The rules you write are mostly business logic, validation and flows.
You don't train from scratch in most cases. The shift toward ML and Deep Learning, and then toward large pre-trained models (LLMs), means your job is largely to integrate existing models: choose a provider, design prompts, connect to your own knowledge (RAG), evaluate responses, handle fallbacks. Training a model from scratch is exceptional (very specific domains, proprietary data, privacy requirements).
You assume structural limits. Models have hallucinations, finite context, cost; they aren't "bugs" you fix with a patch. History (winters, unfulfilled promises) reminds you that designing systems that assume those limits (verification, evaluation, human supervision where applicable) is part of the job.
You follow operational metrics, not philosophical ones. Turing changed the question from "does it think?" to "does it do X so well that a human doesn't notice the difference?". In practice, that translates into metrics: precision, recall, latency, user satisfaction, error rate. Not into debates about consciousness or "real understanding".

Connection with the rest of the guide

Module 2 (ML): History shows that the shift toward "learning from data" wasn't accidental; it was the response to the limits of rules and expert systems.
Modules 4 and 5 (Transformers, LLMs): "Attention Is All You Need" and the scaling of language models are the direct continuation of this timeline.
Module 7 (AI Engineering): The role of "integrating models via APIs" exists because the industry bet on large pre-trained models (LLMs) instead of every company training from scratch.

Exercises

Exercise 1: Order the milestones

Order these milestones from oldest to most recent: (a) Turing Test, (b) Dartmouth Workshop, (c) first AI winter, (d) "Attention Is All You Need", (e) ChatGPT.

See solution

Approximate order: (a) Turing Test (1950) → (b) Dartmouth Workshop (1956) → (c) First winter (~1974) → (d) "Attention Is All You Need" (2017) → (e) ChatGPT (2022).

Exercise 2: Why "winter"?

In one or two sentences: why is the word "winter" used to describe those periods in AI history?

See answer guide

Guide: "Winter" suggests that interest, funding and optimism dropped sharply: it turns "cold" for research and industry. It doesn't mean there was no progress, but that public perception and investment cooled down until new approaches (like ML and Deep Learning) warmed the field back up."

Exercise 3: Rules vs data

What limitation of expert systems (rules) helped shift the focus to Machine Learning (learning from data)?

See solution

Expert systems depended on humans writing and maintaining thousands of rules; they didn't scale well and were brittle outside their domain. Machine Learning let systems learn patterns from data, reducing the need to encode all the knowledge by hand and making it possible to improve with more data.

Exercise 4: The thread in one sentence

Explain in a single sentence why the history of AI (Turing → expert systems → ML → Deep Learning → Transformers) leads to "calling a ChatGPT API" today.

See answer guide

Guide: "The field's evolution went from fixed rules to learning from data (ML), then to deep networks (DL) and to architectures like Transformers, which made enormous language models possible; those models are offered as services (APIs), and that's why today an AI Engineer integrates ChatGPT or similar models instead of programming rules or training from scratch."

Exercise 5: Which lesson do you apply?

Choose one of these statements you sometimes hear and explain in 2–3 sentences why the module's history helps you evaluate it:

A) "In two years we'll have AGI."
B) "LLMs are just hype; there's no science behind them."
C) "Before ChatGPT there was no useful AI."

See answer guide

Guide (examples):
A) History shows cycles of optimism and unfulfilled predictions (the 60s, the 80s); besides, AGI isn't defined operationally. Be cautious with short timelines.
B) LLMs rest on decades of ML, Deep Learning and Transformers; there's science and evidence (benchmarks, products). Not everything is hype; but you do need to distinguish excessive promises from real advances.
C) Before ChatGPT there was already useful AI: spam filters, recommendations, speech recognition, translation, etc. ChatGPT changed access and generation at scale, not the origin of the field.

Exercise 6: Key dates

Match each milestone with its approximate period (one option per row): 1) 1950-56, 2) 1970s, 3) 1980s, 4) 2012, 5) 2017, 6) 2022.

Turing Test and Dartmouth Workshop
First AI winter
Expert systems on the rise
AlexNet wins ImageNet
"Attention Is All You Need"
ChatGPT launches to the public

See solution

Turing Test (1950) and Dartmouth Workshop (1956) → 1) 1950-56
First AI winter → 2) 1970s (mid-70s)
Expert systems on the rise → 3) 1980s
AlexNet wins ImageNet → 4) 2012
"Attention Is All You Need" → 5) 2017
ChatGPT launches to the public → 6) 2022

Quick reference: from history to work

When you design an AI system, you can use this table to remember what history means in practice:

If you're thinking…	History suggests…
"I'm going to write rules for all the domain knowledge"	Expert systems showed it doesn't scale; use data (pre-trained models, RAG, fine-tuning).
"I'm going to train a model from scratch"	In most cases today, pre-trained models are integrated (APIs, RAG, agents); training from scratch is exceptional.
"The model must never fail"	Models have structural limits (hallucinations, finite context); design verification, evaluation and fallbacks.
"Does the model 'understand'?"	The operational question is "does it do the task well?" (metrics); "real understanding" is neither defined nor measurable.
"This is revolutionary / AGI is around the corner"	History shows cycles of hype; contrast it with evidence (benchmarks, real usage conditions).

You don't need to memorize dates; use this table when you make design decisions (rules vs data, train vs integrate, expectations about limits).

Annotated chronology (summary by era)

1950-56 (origins): Turing proposes the operational test ("can the machine do X without a human noticing the difference?"); Dartmouth coins "Artificial Intelligence" and defines the field. The question moves from philosophy to measurement.

1956-70 (first programs): Programs that play checkers, prove theorems, solve logic problems in very narrow domains. Very optimistic predictions ("in 20 years machines will do everything a human does"). They don't come true.

~1974 (first winter): Less funding; critical reports (Lighthill); unfulfilled promises. Research continues but public perception and investment cool down.

1980s (expert systems): Knowledge encoded in rules (MYCIN, XCON); success in niches; expensive to maintain, they don't scale. Second winter (~1987-93): expectations once again above reality.

1990s-2000s (classic ML): Focus on "learning from data"; spam filters, recommendations, voice and image recognition. ImageNet (2010) and competitions allow methods to be compared objectively.

2012 (Deep Learning): AlexNet wins ImageNet; the start of the Deep Learning boom. Deep networks in vision, speech, language, games (AlphaGo, 2016).

2017 (Transformers): "Attention Is All You Need"; the Transformer architecture; the basis of today's LLMs. BERT, GPT-2, GPT-3 (2018-20).

2022-26 (LLMs and products): ChatGPT, Claude, Gemini, Llama, Mistral; APIs, RAG, agents. The practical work of an AI Engineer revolves around integrating these models.

Use this chronology when you want to place a milestone or explain to someone "where what you use today comes from".

One-page summary

Origins (1950-56): Turing proposes an operational test ("can the machine do X without a human noticing the difference?"); Dartmouth coins "Artificial Intelligence". The question moves from philosophy to measurement.
First programs (1956-70): Programs that play checkers, prove theorems, solve logic in very narrow domains. Very optimistic predictions; they don't come true.
First winter (~1974): Less funding; critical reports; unfulfilled promises.
Expert systems (1980s): Knowledge in rules (MYCIN, XCON); success in niches; expensive to maintain. Second winter (~1987-93).
Classic ML (1990s-2000s): Focus on "learning from data"; spam, recommendations, voice, image. ImageNet (2010) and competitions allow methods to be compared.
Deep Learning (from 2012): AlexNet wins ImageNet; deep networks in vision, speech, language, games (AlphaGo, 2016).
Transformers (2017): "Attention Is All You Need"; the basis of today's LLMs. BERT, GPT-2, GPT-3 (2018-20).
LLMs and products (2022-26): ChatGPT, Claude, Gemini, Llama, Mistral; APIs, RAG, agents.
Implications for an AI Engineer: Don't program rules by hand for domain knowledge; don't train from scratch in most cases; assume structural limits (hallucinations, finite context); follow operational metrics (precision, recall, latency).
Common mistakes: "It all started with ChatGPT" (false); "The winters mean AI is useless" (false); "Deep Learning appeared out of nowhere in 2012" (false).
Resources: Stanford HAI, Wikipedia (history of AI, AI winters), "Attention Is All You Need" (2017), Wait But Why, the Deep Learning Book.
Design implications: If you think "rules by hand" → use data (models, RAG, fine-tuning). If you think "train from scratch" → in most cases integrate pre-trained models. If you think "the model must not fail" → design verification, evaluation and fallbacks.

Summary of implications for AI Engineering

The history you've just read has direct consequences for how you work as an AI Engineer:

Don't program rules by hand for domain knowledge. Expert systems showed it doesn't scale; today knowledge comes from data (pre-trained models, RAG, fine-tuning). The rules you write are mostly business logic, validation and flows.
Don't train from scratch in most cases. The shift toward ML and Deep Learning, and then toward large pre-trained models (LLMs), means your job is largely to integrate existing models: choose a provider, design prompts, connect to your own knowledge (RAG), evaluate responses, handle fallbacks.
Assume structural limits. Models have hallucinations, finite context, cost; they aren't "bugs" you fix with a patch. Design systems that assume those limits (verification, evaluation, human supervision where applicable).
Follow operational metrics, not philosophical ones. Turing changed the question from "does it think?" to "does it do X so well that a human doesn't notice the difference?". In practice, that translates into metrics: precision, recall, latency, user satisfaction.
Contrast claims with evidence. When you hear "revolutionary", "AGI is around the corner" or "this changes everything", remember the history (cycles of hype, unfulfilled predictions) and contrast it with benchmarks and real usage conditions.
Use the timeline when you explain "where what you use comes from". If someone asks why you integrate models via API instead of programming rules or training from scratch, the history (rules → ML → DL → Transformers → APIs) gives the context in one sentence.

Use this summary when you make design decisions (rules vs data, train vs integrate, expectations about limits).

Notes for going deeper

Why not memorize dates? The history of AI isn't assessed by exact dates but by understanding the thread: rules → data (ML) → deep networks (DL) → Transformers and LLMs → APIs and products. If you remember that thread and the two winters (unfulfilled promises, less funding), you have the essentials.

What to read first if you want to expand? Stanford HAI (Brief History of AI) is accessible and short. If you want to go to the source, Turing's paper (1950) is in the public domain. If you want to understand Transformers, the paper "Attention Is All You Need" (2017) is technical but it's the direct reference for today's LLMs.

How to use this lesson in the bootcamp or in another guide? When you see "RAG", "ChatGPT API", "pre-trained model", remember that it's the result of the evolution you've just read: you don't program rules by hand or train from scratch in most cases; you integrate models that learned from data. History explains why the center of gravity is there.

What questions to ask when you hear "revolutionary" or "AGI is around the corner"? On what benchmark? Under what conditions? Compared with what? History shows cycles of hype; contrast claims with evidence (benchmarks, real usage conditions) and with what's actually possible today (lesson 05).

Questions to reflect on

Why is it not true that "it all started with ChatGPT"? Because AI has roots in the 50s (Turing, Dartmouth); LLMs are the result of decades of ML, Deep Learning and architectures (Transformers). ChatGPT is a milestone of product and access, not the origin of the field.

Why don't the winters mean AI "failed"? Because the winters were periods of less funding and lower expectations, not of zero progress. Research continued; what dropped was hype and investment. Afterward came ML, Deep Learning and LLMs.

Why did expert systems drive the shift toward ML? Because they depended on humans writing and maintaining thousands of rules; they didn't scale well and were brittle outside their domain. ML let systems learn patterns from data, reducing the need to encode all the knowledge by hand.

Why did Deep Learning "take off" in 2012 and not before? Because neural networks had existed since the 50s-60s; what changed in 2012 was the combination of data at scale, GPUs and architectures that made it possible to train deep networks successfully. It was a turning point, not a new invention.

What does the history imply for an AI Engineer today? Not programming rules by hand for domain knowledge; not training from scratch in most cases; assuming structural limits (hallucinations, finite context); following operational metrics (precision, recall, latency), not philosophical ones.

Executive summary (for quick review)

Origins (1950-56): Turing (operational test) and Dartmouth ("Artificial Intelligence"). The question moves from philosophy to measurement.
First programs and winter (~1974): Limited programs; unfulfilled promises; less funding.
Expert systems and winter (~1987-93): Rules by hand; success in niches; they don't scale; less investment.
Classic ML (1990s-2000s): Learning from data; ImageNet and competitions; data as fuel.
Deep Learning (from 2012): AlexNet, deep networks in vision, speech, language, games (AlphaGo).
Transformers (2017): "Attention Is All You Need"; the basis of today's LLMs.
LLMs and products (2022-26): ChatGPT, Claude, Gemini, Llama, Mistral; APIs, RAG, agents.
Implications: No rules by hand for knowledge; no training from scratch in most cases; assume limits; operational metrics.
Mistakes: "It all started with ChatGPT" (false); "Winters = AI is useless" (false); "Deep Learning out of nowhere in 2012" (false).
Resources: Stanford HAI, Wikipedia (history, winters), "Attention Is All You Need", Wait But Why, the Deep Learning Book.

Summary

AI has roots in the 50s (Turing, Dartmouth); then came limited programs, expert systems and two winters (less funding and lower expectations).
The shift toward learning from data (ML) and then deep networks (DL) made it possible to scale without depending only on hand-written rules.
Transformers (2017) and LLMs led to products like ChatGPT and to a situation where much of the practical work is integrating models via APIs (AI Engineering).
Knowing this history helps you not think that "it all started with ChatGPT" and to understand that the current state rests on decades of research, data and compute.
For an AI Engineer, the history implies: don't program rules by hand for domain knowledge; don't train from scratch in most cases; assume structural limits (hallucinations, finite context); and follow operational metrics (precision, recall, latency), not philosophical ones.

Going deeper: how to follow the history

If you want to expand on what you saw in this lesson, you can follow these threads:

Turing and the origins: Turing's paper (1950) is short and accessible; it's in the public domain. If you read it, you'll see that many of the objections he anticipated ("the machine is only simulating", "it has no emotions") still come up today. The idea of changing the question from "does it think?" to "does it do X so well that we don't notice the difference?" is the one that still guides system evaluation (metrics, benchmarks).

The winters: If you want to understand why funding dropped in the 70s and the 80s, look up "Lighthill report" (1973) and "expert systems winter". You'll see the pattern repeat: very high promises, narrow results, critical reports, cuts. It doesn't mean AI "failed"; it means public perception and investment cooled down until new approaches (ML, Deep Learning) raised expectations again.

ImageNet and Deep Learning: The AlexNet paper (2012) and the story of ImageNet are a good starting point for understanding why Deep Learning took off when it did: data at scale, GPUs, and a competition that allowed methods to be compared objectively. That culture of benchmarks later carried over to language (GLUE, SuperGLUE, etc.) and is still central today.

Transformers and LLMs: The paper "Attention Is All You Need" (2017) is technical but it's the direct reference for almost all of today's LLMs. If you don't want to read the paper, look for accessible summaries of "what is a Transformer" and "why it made such large language models possible". You'll see that the idea of "attention" (relating each element of a sequence to all the others) is what made it possible to train much larger models, and in parallel.

From history to work: When you design a system (RAG, classifier, agent), ask yourself: am I programming rules by hand for domain knowledge? (History suggests it doesn't scale.) Am I training from scratch? (In most cases today, pre-trained models are integrated.) Am I assuming the model won't fail? (History suggests designing verification, evaluation and fallbacks.)

Additional resources

Stanford HAI: A Brief History of AI — An accessible summary of the history of AI from Turing to today; a good starting point for expanding on what you saw in this lesson (in English).
Wikipedia: History of artificial intelligence — Detailed chronology, milestones and references; useful for looking up specific dates and names. Complements this lesson's timeline.
AI Winters (Wikipedia) — An explanation of what the AI winters were, when they happened and why; complements this lesson's table. Useful for understanding the optimism → disillusionment → less investment pattern.
Vaswani et al., "Attention Is All You Need" (2017) — The founding paper of the Transformer architecture; technical, but it's the direct reference for today's LLMs (in English). If you don't read the paper, look for accessible summaries of "what is a Transformer".
The AI Revolution: The Road to Superintelligence (Wait But Why) — A long, accessible article about the history and expectations of AI; it helps place the public debate (in English). Useful for connecting history with current expectations.
Deep Learning (Goodfellow, Bengio, Courville) — The reference book on Deep Learning; chapter 1 has historical context on neural networks and their evolution (in English, free online). Complements the "Deep Learning and the current boom" section of this lesson.

← Previous2. Definitions of AI: AI vs ML vs DL vs GenAI Next →4. Types of AI: Narrow vs General, Weak vs Strong