Skip to content
04 of 06From the Caves to AGI

Chapter 3 — Learn (≈ 1956–2012)

Library

Series and technical notes.

You are in From the Caves to AGI · Learn.

Watch video, summary and related content

Estimated reading10 min

This chapter explains how AI moved from writing expert knowledge by hand, rule by rule, to inferring it automatically from data. By the end, you will understand why expert systems worked well for years and then hit a ceiling, what conceptual shift statistical learning introduced by reframing the problem as optimization rather than formalization, and how backpropagation made multilayer neural networks systematically trainable. The chapter runs from symbolic AI and the field's winters to AlexNet in 2012. No technical background is required, although Chapters 1 and 2 on representation and mechanization are useful prerequisites.

The Dartmouth Conference did not unveil a finished technology. It launched a research program. Its hypothesis was ambitious: if human reasoning could be described precisely enough, a machine could execute it too. The following decades showed that this idea was not absurd, but that it was far harder than it first appeared.

This chapter follows the period in which AI gradually moved away from relying mainly on hand-written rules and toward data, statistics and optimization. The change was neither clean nor instantaneous. Different approaches coexisted for a long time, with partial successes and very different limitations. Still, the overall direction eventually became clear: the field moved away from asking how to enumerate correct reasoning explicitly and toward asking how a machine could extract useful regularities from examples.


1. The age of rules: when intelligence was written by hand

The first symbolic systems

Early AI programs were built around a powerful intuition: if reasoning can be expressed as a sequence of formal steps, perhaps we only need to represent those steps and let the machine traverse them. Systems such as Logic Theorist, presented in 1956, and GPS, the General Problem Solver, described in the late 1950s and early 1960s, followed this direction. Both demonstrated something important: a machine could search, combine rules and produce non-trivial chains of inference.

The problem was that these systems performed best where the world was already highly formalized. Theorems, games and puzzles admit relatively clean states, rules and goals. The real world almost never does.

Expert systems: the mature symbolic paradigm

This approach reached its most solid form in expert systems. Rather than aiming for general intelligence, they tried to capture knowledge in a narrow domain through rules, facts and heuristics constructed with human specialists.

MYCIN, developed at Stanford in the 1970s, became one of the best-known examples. It recommended treatments for serious bacterial infections and showed that a rule-based system could perform at a high level inside a tightly bounded domain. XCON, also called R1, automated VAX computer configuration at Digital Equipment and became one of the most cited industrial examples of the period.

What matters about these systems is not only that they worked, but why. They worked well when the domain was relatively stable, when the decision vocabulary could be bounded and when expert knowledge could realistically be converted into maintainable rules.

Symbolic AI: knowledge written by hand
For three decades, AI represented expert reasoning as formal rules. It worked inside bounded domains. It hit a ceiling when knowledge no longer fit into rules.
Paradigm
MYCIN
The limit
Paradigm
Intelligence as a list of rules
If reasoning can be expressed as a sequence of formal steps, it is enough to represent those steps and let the machine traverse them. A human expert writes the knowledge; the machine applies it.
E
Expert
R
Rules
M
Inference engine
D
Decision
Advantage →every decision can be audited: you know exactly which rule was applied and why
Real example · Stanford, 1970s
MYCIN — 450 rules to diagnose infections
MYCIN recommended antibiotic treatments for serious bacterial infections. Its knowledge base contained rules written with medical specialists, with certainty factors associated with each inference.
R001IF the organism is gram-positive AND the site is blood
THEN consider Staphylococcus (0.7)
R002IF fever > 38.5 AND culture is negative
THEN consider broad-spectrum antibiotics (0.65)
+ 448 more rules, all written by hand by physicians
Result →performance comparable to specialists within its narrow, well-defined domain
The ceiling
The bottleneck: acquiring the knowledge
Maintaining an expert system was not a matter of writing rules once. It meant revising them when the domain changed, extending them to cover exceptions, and resolving conflicts between contradictory rules. As the domain grew, the knowledge base became unmanageable.
Narrow domain
~50 rules — viable
Medium domain
~450 rules — costly
Open domain
no visible limit — infeasible
The problem →was not computational but human: extracting and formalizing expert knowledge was slow, costly and fragile

Why that path eventually hit a ceiling

The limitation appeared when knowledge stopped being small, stable and easy to formalize. Maintaining an expert system did not mean writing the rules once. It meant revising them, extending them, resolving conflicts among them and absorbing exceptions. As the domain grew more complex, so did the knowledge base.

This exposed one of symbolic AI's major bottlenecks: knowledge acquisition. Extracting expert knowledge and translating it into a formal base was expensive, slow and fragile. The problem was not only computational. It was also human and organizational.

The so-called AI winters are closely related to this collision between promise and reality. The first was tied to inflated expectations, complexity barriers and institutional criticism such as the 1966 ALPAC report and the 1973 Lighthill report. The second, in the late 1980s and early 1990s, is commonly associated with exhaustion of the expert-system paradigm, the knowledge-acquisition bottleneck and the collapse of the Lisp-machine market that had supported much of that ecosystem (JRC AI Watch).

The AI winters: the same pattern, twice
Between 1956 and 2012, the field went through two cycles of euphoria and collapse. Each time the cause was the same: promises exceeded what the technology of the time could deliver.
First cycle
Second cycle
What changed
1956 – 1974
First summer and first winter
Dartmouth 1956 unleashed outsized expectations: some researchers predicted general AI within 20 years. Rosenblatt's perceptron seemed to open a path to genuine learning. Minsky and Papert (1969) demonstrated its limits. Funding collapsed.
Summer
Dartmouth 1956 · perceptron · predictions of general AI within 20 years
Winter
Minsky and Papert (1969) · ALPAC report · Lighthill report (1973) · cuts
The pattern →excessive promise, visible limits, funding cuts
1980 – 1993
Expert systems: summer and second winter
Expert systems (MYCIN, XCON, R1) revived interest. The AI market reached $1 billion. Maintaining knowledge bases did not scale. The Lisp-machine market collapsed. The field fragmented.
Summer
MYCIN · XCON · $1B AI market · massive corporate investment
Winter
Rules that do not scale · Lisp-market collapse · DARPA cuts projects
The pattern →identical to the previous one, applied to a different technology
1993 – 2012
The quiet accumulation: three factors converge
Without a declared summer, three changes accumulated in parallel. When all three converged at sufficient scale, the result became visible enough to be undeniable.
D
Massive datasets
The internet and digitization generated unprecedented volumes of text, images and audio. ImageNet: 1.2 million labeled images.
G
Accessible GPUs
Graphics cards, designed for video games, turned out to be ideal for the matrix algebra of neural-network training.
B
Shared benchmarks
The ImageNet Large Scale Visual Recognition Challenge made progress measurable, comparable and cumulative.
2012 →AlexNet showed that the convergence was real: top-5 error fell from 25.8% to 15.3% in one jump

2. The statistical turn: learning from examples

The paradigm shift was not simply about using more data. It changed the central question. Instead of asking which rules had to be written to solve a task, researchers increasingly asked which regularities a model could infer if it were shown enough examples.

Generalize without memorizing

Learning means capturing a regularity that continues to work outside the training set, not merely reproducing it. This problem—generalization—became central with the rise of statistical learning.

Vapnik's statistical learning theory offered a language for reasoning about capacity, empirical risk and control of overfitting. In parallel, Valiant formalized learning as the acquisition of knowledge without explicit programming. Machine learning therefore began to consolidate not as a collection of tricks, but as a discipline with foundations addressing what can be learned, with how much data and under what conditions.

Probability also stopped being an accessory and moved to the center. In many domains, a system does not only need to decide. It also needs to represent uncertainty, combine incomplete evidence and update its beliefs when new data arrives.

Optimize parameters instead of writing rules

If a model learns from examples, its parameters must be adjusted to reduce error. That idea feels obvious today, but it reorganized the entire field. Learning increasingly became an optimization problem.

The classic precursor to stochastic optimization already appears in Robbins and Monro (1951). Later, stochastic gradient descent made it possible to train models on large datasets without recalculating the error over every example at each step. Regularization and validation techniques were added so that a model would not only fit the past well, but preserve its ability to generalize.

Neural networks were not the field's only focus during this phase. Decision trees, kernel methods, probabilistic models and ensemble techniques also grew. The underlying shift was not yet “everything is deep learning.” It was that many tasks were starting to be described more naturally as statistical fitting problems than as lists of hand-written rules.

Representation is learned too

This is where the decisive difference between many classical methods and deep networks appears. In many earlier approaches, a human had to design much of the relevant feature representation manually. The model learned from those features, but it did not learn the representation itself very well.

Multilayer neural networks promised something more ambitious: useful intermediate representations learned directly from data. The idea had existed for much longer, but for years it was difficult to turn into a robust practice.

The training loop: three pieces, one mechanism
Every machine-learning model adjusts its parameters through the same loop, from a 1980 regression to GPT-4. The three pieces are inseparable.
Measure the error
Propagate
Adjust
Piece 1 · Probability
Quantify how wrong the model is
The first element is a loss function. It compares the model's prediction with the correct answer and produces a number that represents the error. The larger it is, the worse. Without this measure there is no direction for improvement.
Loss function (cross-entropy)
ℒ = − Σ y · log(ŷ)
y = true value  ·  ŷ = model prediction  ·  ℒ = total error
Makes it possible →to calculate in which direction the parameters should change to reduce the error
Piece 2 · Backpropagation
Distribute responsibility for the error layer by layer
The chain rule applied to multilayer networks. The calculated error propagates backward from the output, assigning each weight a measure of how much it contributed to the failure. Without this, training deep networks was unfeasible.
Gradient per parameter (chain rule)
∂ℒ/∂W = ∂ℒ/∂a · ∂a/∂W
∂ℒ/∂W = how much W contributed to the total error  ·  applied to each layer, from output to input
Rumelhart, Hinton & Williams (1986) →made backpropagation the central method for training multilayer networks
Piece 3 · Optimization
Move in the direction of lower error
Stochastic gradient descent: update each weight by a small fraction (the learning rate) in the direction opposite the gradient. Repeat with each batch of data. The model converges toward parameters that minimize the loss.
Weight update (SGD)
W ← W − η · ∇ℒ(W)
η = learning rate  ·  ∇ℒ(W) = gradient calculated by backprop
The complete loop
Data
Predict
W ←
The same loop →identical in a 1980 logistic regression and in GPT-4 training; the scale changes, the mechanism does not

3. The perceptron, its critique and the return of neural networks

The first neural excitement

Rosenblatt's perceptron first appeared as a proposal in 1957 and was formalized more fully in his 1958 paper, The Perceptron: A Probabilistic Model for Information Storage and Organization in the Brain. It was one of the first influential formulations of a trainable artificial neuron.

The promise was powerful: a machine could adjust weights from examples and learn a decision boundary rather than receiving it fully specified. This opened a path distinct from symbolic AI. Instead of explicitly representing chains of inference, the system adjusted parameters to discriminate patterns.

Minsky and Papert's critique

The classic critique came with Minsky and Papert's Perceptrons in 1969. Their analysis showed important limits of single-layer perceptrons and used XOR (exclusive OR) as a central case: an operation that returns 1 only when its two inputs differ and 0 when they are equal. It is the simplest Boolean function that a one-layer perceptron cannot learn, because its four possible cases occupy the corners of a square in a pattern that no straight line can separate correctly.

The problem was not that the analysis was wrong. The problem was that for years it was interpreted as a much broader practical rejection than it actually demonstrated. In time, it became clear that a network with hidden layers could represent functions beyond the reach of a simple perceptron. The difficulty was not only representational. It was also a training problem.

Backpropagation and multilayer networks

That obstacle began to break when training deep networks stopped being a vague intuition and became an operationally convincing recipe. The 1986 paper by Rumelhart, Hinton and Williams made error backpropagation the emblematic procedure for adjusting multilayer networks. The idea was to propagate error backward from the output to estimate how each weight should change.

The principle had earlier precedents, but 1986 was the inflection point that made it central to the neural-network community (history of backpropagation). From then on, neural networks were no longer only a biologically inspired promise. They became a family of models that could be trained with a general technique.

Why a perceptron cannot learn XOR
A perceptron classifies by drawing a straight line. XOR has four cases arranged so that no line can separate them. That incompatibility is geometric, not algorithmic.
The task
The perceptron
The problem
The proof
The solution
XOR · The function
Separating with a line means: all 0s on one side, all 1s on the other
A perceptron classifies by drawing a line in the input plane. For it to work, all points from each class must lie on opposite sides of that line. AND allows this: its four cases have the 1s grouped in one corner. XOR does not: its 0s and 1s occupy alternating diagonal corners.
AND — separable ✓
A B 0 1 0 1 0 0 0 1
XOR — not separable ✗
A B 0 1 0 1 0 1 1 0 ?
The problem →in AND the three 0s are together and the only 1 is isolated: a diagonal line separates them cleanly. In XOR the 0s and 1s alternate diagonally, with no side on which either class can be grouped.
The perceptron · How it classifies
A perceptron weights and sums the inputs, then applies a threshold. Geometrically, that is a straight line.
A perceptron takes inputs A and B, multiplies them by weights w₁ and w₂, adds a bias term b, and decides: if the result is above 0, it predicts class 1; otherwise class 0. That decision rule divides the plane into exactly two regions separated by a straight line. Learning adjusts w₁, w₂ and b so that this line separates the classes as well as possible.
What the perceptron computes
w₁·A + w₂·B + b
if > 0 → class 1 · if ≤ 0 → class 0
Each combination of weights defines a different line. Learning searches for the one that best separates the classes.
class 0 class 1 w₁·A + w₂·B + b = 0
The limit →the weights can change the line's slope and position, but it is always a line. A perceptron has no additional degrees of freedom beyond those.
Not linearly separable · The geometric problem
Every line you try leaves at least one point on the wrong side
XOR's diagonal pattern makes the problem unsolvable for any linear boundary. The angle does not matter: a horizontal line separates by B but mixes 0s and 1s within each row. A vertical line does the same by column. A diagonal separates (0,0) and (1,1) from (0,1) and (1,0), but that does not match XOR. No angle works.
Horizontal line
0 1 1 0
Vertical line
0 1 1 0
Diagonal line
0 1 1 0
The conclusion →the problem is not that the perceptron fails to find the right line. That line does not exist. XOR requires a boundary that bends, while a single-layer perceptron can only draw a straight one.
Algebraic proof · The contradiction
The four conditions required by XOR are mathematically incompatible
If a solution (w₁, w₂, b) existed, it would have to classify all four cases simultaneously. Each case imposes an inequality on the weights. Adding the two conditions for the cases with output 1 produces a result that directly contradicts the condition for (1,1).
(0,0) → 0 b < 0
(0,1) → 1 w₂ + b > 0
(1,0) → 1 w₁ + b > 0
(1,1) → 0 w₁ + w₂ + b < 0
Add (0,1) + (1,0):  w₁ + w₂ + 2b > 0
↓  because b < 0, then −2b > −b
therefore:  w₁ + w₂ > −2b > −b
↓  but (1,1) requires the opposite
w₁ + w₂ + b < 0  →  w₁ + w₂ < −b   ✗  contradiction
Consequence →the optimizer is not merely failing to find a solution. There is no (w₁, w₂, b) that satisfies all four conditions. The impossibility is mathematical, not computational.
Multilayer networks · The solution
Two hidden neurons bend the space. The output boundary is still a straight line.
Each hidden neuron draws its own boundary in the input space: one acts like OR (active if at least one input is 1) and another like AND (active only if both are 1). Together they create a band containing exactly the two XOR=1 cases. After projection into the new space, those two points collapse to the same position and a single straight line is enough.
Original space — two boundaries
A B 0 1 0 1 h₁ h₂ 0 1 1 0
Hidden space — one boundary
h₁ (OR) h₂ 0 1 0 1 0 1 ×2 0
The key →(0,1) and (1,0) collapse to the same point in the hidden space. The hidden layer does not classify: it transforms. The output neuron still draws a straight line, but in a space that the hidden layer has already bent.

4. NLP before transformers

Natural-language processing followed a trajectory for a long time that was very different from the one transformers would later impose. Before large neural models, statistical and sequential approaches dominated the field.

N-gram models, whose lineage partly traces back to Shannon's ideas about sequences, estimated the probability of a word from a small number of preceding words. They were simple, effective and extremely useful, but had an obvious limitation: their effective memory was short.

Hidden Markov models dominated tasks such as speech recognition and sequence labeling for years. Later, conditional random fields provided a powerful alternative for segmenting and labeling sequences while relaxing some strong HMM restrictions.

All of these approaches were valuable, but they shared a deeper limitation: they handled local correlations and tractable probabilistic structures well, but they did not learn deep contextual representations of language. Long context, semantic ambiguity and open-ended composition remained difficult.

NLP before the Transformer: three approaches, one common limit
For four decades, natural-language processing was built on statistics and sequences. Each approach was a real advance, yet shared the same underlying limit: context was lost.
N-grams
HMM
CRF
Perspective
Statistical approach · 1980s–2000s
N-grams: predict the next word from local context
An N-gram model estimates the probability of a word using only the immediately preceding fragment. A trigram looks at the previous two words. This was a foundation of speech recognition and statistical machine translation for decades.
Example — trigram prediction
The
cat
eats
___
active window: cat + eats → P(next)
fish
32 %
mice
24 %
a lot
14 %
The limit →"The cat that my neighbor bought on Tuesday eats ___" depends on "cat", nine words away. A trigram cannot reach it: it only sees two words back.
Hidden-state model · 1970s–2000s
HMM: labels as states that generate words
Hidden Markov Models treat grammatical categories as unobserved states that generate visible words. The Viterbi algorithm infers the most probable state sequence. HMMs dominated speech recognition and part-of-speech tagging for two decades.
Part-of-speech tagging (POS tagging)
Hidden states
DET
NOUN
VERB
DET
NOUN
Observed words
The
cat
eats
the
fish
The limit →it assumes each word depends only on its current state, not on global context. Long-range dependencies and semantic ambiguity remain outside its reach.
Discriminative model · 2001–2010s
CRF: model the label directly, with hand-engineered features
Conditional Random Fields improved on HMMs by directly modeling P(labels | words) and allowing arbitrary contextual features. They were state of the art for named-entity recognition until neural networks displaced them.
Named-entity recognition (NER)
Yesterday Alan Turing published in Cambridge
PERSON
PLACE / ORG
Other
Hand-engineered features
Starts with a capital letter
Previous word is an article
Word suffix (-ing, -tion)
The limit →the features must be designed by hand. There is no representation of meaning: "bank" (financial institution) and "bank" (river bank) are distinguished by context, but the CRF has no such semantic layer.
The common pattern · 1980–2012
What the three approaches could not do
N-grams, HMMs and CRFs were real advances, each building on the previous one. But all three shared the same underlying limitation: context was processed locally and representations were designed by hand. The Transformer addressed exactly those two fronts.
Before the Transformer
Context limited to a local window or current state
Features manually designed by linguists
No semantic representation of words
A different model for each task
The Transformer (2017)
Attention over the full sequence context
Representations learned from data
Embeddings with semantic and positional information
One base model, multiple tasks through fine-tuning
The transition →the field did not abandon statistics; instead, it stopped requiring humans to design the representations. Representation itself became something the model learned.

5. The neural renaissance: what changed before 2012

The resurgence of deep learning cannot be explained by one cause. It was the convergence of several changes that had remained incomplete for decades.

More data, more compute, better shared benchmarks

First came scale. The mass digitization of text, images, audio and online activity produced volumes of data that earlier approaches had rarely been able to exploit. In vision, ImageNet turned that scale into concrete infrastructure for comparative research.

Then came suitable hardware. GPUs, designed for intensive parallel computation, matched the linear algebra of neural-network training unusually well. The change was operational: models that had seemed interesting but impractical for years could now be trained in reasonable time.

Shared benchmarks were also necessary to measure progress. Without common benchmarks, every group can look strong on its own problem. With benchmarks, progress becomes visible, comparable and cumulative.

The immediate prelude to the explosion

Before AlexNet there was an important prologue. Work such as Reducing the Dimensionality of Data with Neural Networks in 2006 and Greedy Layer-Wise Training of Deep Networks in 2007 helped reopen the problem of training deep networks when it was still unclear whether they could scale reliably from direct initialization.

That period did not solve everything, but it changed the intellectual climate. Deep networks stopped looking like a historical curiosity and began to recover empirical credibility.

2012 as a threshold

The natural endpoint of this chapter is 2012. AlexNet trained a deep network on 1.2 million ImageNet challenge images using two GTX 580 GPUs for 5–6 days, together with several design choices that already pointed toward the next phase.

The improvement was large enough to redirect the field. AlexNet did not single-handedly inaugurate the entire modern era, but it marks the threshold after which deep learning stopped being one promising line among several and became the dominant axis of progress in vision and, soon afterward, speech and language.


6. What this period prepared

By 2012, AI had changed profoundly. It had not completely abandoned rules or logic, but it no longer treated them as the primary route to building capable systems at scale. The center of gravity had shifted toward models that learn from data, adjust parameters and improve as examples, compute and representation quality grow.

That shift prepares the ground for the next chapter. The story is no longer mainly about whether a machine can learn from data, but about what happens when that learning finds enough scale.

Next chapter

Chapter 4 — Scale → — AlexNet, the Transformer and scaling laws: what happened when learning met massive datasets, GPUs and new architectures.


7. References

Core sources
Key Source Short description
R1 Newell & Simon (1956) — The Logic Theory Machine Early landmark example of automated symbolic reasoning.
R2 Newell, Shaw & Simon (1959–1961) — GPS, A Program that Simulates Human Thought Emblematic program of heuristic search.
R3 McDermott (1980) — R1: An Expert in the Computer Systems Domain Foundational account of XCON/R1 for VAX system configuration.
R4 Buchanan & Shortliffe (1984) — evaluation of MYCIN Performance, expert disagreement and evaluation limits in expert systems.
R5 JRC AI Watch (2020) — Historical Evolution of Artificial Intelligence Historical framework for AI winters, symbolic AI and the transition to ML.
R6 Vapnik — The Nature of Statistical Learning Theory Foundations of generalization and statistical learning.
R7 Valiant (1984) — A Theory of the Learnable Formalization of learning without explicit programming.
R8 Robbins & Monro (1951) — A Stochastic Approximation Method Classical precursor to stochastic learning updates.
R9 Rosenblatt (1958) — The Perceptron: A Probabilistic Model for Information Storage and Organization in the Brain Classical perceptron formulation.
R10 Minsky & Papert (1969) — Perceptrons Classical analysis of single-layer perceptron limitations.
R11 Rumelhart, Hinton & Williams (1986) — Learning representations by back-propagating errors Canonical paper on backpropagation in multilayer networks.
R12 Schmidhuber — history of backpropagation Historical summary of precursors before 1986.
R13 Jurafsky & Martin — chapter on n-grams Classical framework for language models before transformers.
R14 Rabiner (1989) — A Tutorial on Hidden Markov Models Classical HMM reference for sequences and speech.
R15 Lafferty, McCallum & Pereira (2001) — Conditional Random Fields Introduction of CRFs for labeled sequences.
R16 Deng et al. (2009) — ImageNet: A Large-Scale Hierarchical Image Database Dataset and benchmark central to computer vision.
R17 Hinton & Salakhutdinov (2006) — Reducing the Dimensionality of Data with Neural Networks Reopening deep training before the boom.
R18 Bengio et al. (2007) — Greedy Layer-Wise Training of Deep Networks Role of layer-wise pretraining in deep networks.
R19 Krizhevsky, Sutskever & Hinton (2012) — ImageNet Classification with Deep Convolutional Neural Networks AlexNet and the 2012 threshold.
R20 LeCun, Bengio & Hinton (2015) — Deep Learning Historical and technical review of deep learning's rise.

Frequently asked questions

Why did expert systems work well and then hit a ceiling?
They worked well while the domain was stable and bounded, such as bacterial-infection diagnosis in MYCIN or VAX system configuration in XCON. The problem was not initial performance but maintenance: as a domain grew more complex, the rule base required constant revision, generated conflicts and accumulated exceptions without a systematic mechanism for resolving them. The bottleneck was not primarily computational but human: extracting and formalizing expert knowledge was expensive, slow and fragile.

What conceptual change did statistical learning introduce compared with symbolic AI?
The shift was not merely toward more data; it changed the central question. Symbolic AI asked which rules had to be written to solve a task. Statistical learning asked which regularities a model could infer from enough examples. Learning became an optimization problem—adjusting parameters to reduce error—rather than formalizing expert knowledge in a rule base.

Why did backpropagation unlock neural networks?
It provided a general operational recipe where there had previously been mostly intuition. Rumelhart, Hinton and Williams' 1986 paper showed how to propagate error backward from the output to estimate how each weight in each layer should change. Ideas for training multilayer networks had existed before, but without a systematic, reproducible procedure, deep networks could not be trained reliably and the field remained limited to shallow models.

Why did the AI winters happen if the basic ideas were sound?
Because the gap between what the field promised and what it could deliver with the available resources was too large. The first winter followed inflated expectations and complexity barriers highlighted by reports such as Lighthill's in 1973. The second, in the late 1980s, arrived when expert systems exposed their scaling limits and the specialized AI-hardware market collapsed. The ideas were not necessarily wrong; the data, compute and training algorithms were not yet sufficient for what those ideas required.

Keep learning
Next chapterScaleFrom the Caves to AGI