The history of AI
What the founding documents of artificial intelligence actually said, separated from the folklore that grew up around them.
The history of artificial intelligence is unusually badly served on the web, and for a specific reason. It is evergreen, it is heavily searched, and it is cheap to write from other people’s summaries — so the same dates, the same quotations and the same causal stories have been copied across thousands of pages, acquiring errors as they go. Turing gets credited with a pass mark he never set. Minsky and Papert get blamed for a claim their book does not make. The Dartmouth proposal gets described as promising human-level machines within a decade, which is not what it says.
These twenty pages go back to the proposal, the paper, the report or the press release, and separate what the document says from what everyone now believes it says. Where a date is certain it is given. Where only a decade or an ordering is certain, the page says so rather than inventing a year, and where a famous quotation cannot be verified it is paraphrased and labelled as a paraphrase. That makes for slightly duller prose than the version with an invented Turing epigram, and it makes for a page you can cite.
A companion page, the single-page timeline from Dartmouth to now, runs the same material chronologically if that is what you came for. This cluster goes one level deeper on each episode.
The Dartmouth Workshop and the Naming of AI
What the 1955 Dartmouth proposal actually promised, who wrote it, who turned up, and why calling it a conference is misleading.
9 min read
The Turing Test: What Turing Wrote, and What People Think He Wrote
Turing's 1950 paper proposed an imitation game and made one dated prediction. Neither is the pass/fail benchmark the phrase now describes.
10 min read
The Perceptron, and the Book That Stopped It
Rosenblatt's 1958 perceptron, the Mark I machine, and what Minsky and Papert's 1969 book actually proved — which is narrower than its reputation.
10 min read
ELIZA and the First Chatbot Illusion
How Weizenbaum's 1966 program worked, why the DOCTOR script is not the same thing as ELIZA, and why its author spent the next decade arguing against it.
9 min read
The AI Winters: What Froze and Why
Two funding collapses, traced to the specific reports and specific broken promises that caused them, and what carried on working through both.
11 min read
Expert Systems: The Boom Everyone Forgot
Why rule-based systems became a real industry in the mid-1980s, what specifically broke them, and where the technology quietly survives.
10 min read
Backpropagation's Long Road to Acceptance
Six independent discoveries between 1960 and 1986, in order, and why the 1986 paper is the famous one despite not being first.
10 min read
Deep Blue and What Beating Kasparov Proved
The 1996 and 1997 matches, the machine's actual architecture, and why the lesson most people drew from it was the wrong way round.
10 min read
ImageNet and the 2012 Moment
AlexNet's 2012 result, the error rates it beat, and why the dataset built between 2007 and 2009 was the harder half of the achievement.
10 min read
AlphaGo, Move 37, and What Self-Play Changed
The 2016 Lee Sedol match, the one-in-ten-thousand move, and the four properties of Go that made the result possible and kept it from generalising.
10 min read
The Long History of Machine Translation
Seventy-five years from Weaver's 1949 memorandum to neural systems, with each era's headline result stated inside its own evaluation.
11 min read
word2vec and the Idea That Meaning Has Coordinates
The 2013 papers, the king-minus-man example, and the evaluation detail that makes the famous analogy result weaker than it looks.
9 min read
How the Transformer Paper Came About
Attention Is All You Need was a translation-throughput paper. What it proposed, what it reported, and how much of a modern transformer is not in it.
10 min read
GPT-1 to GPT-3: What Each One Added
Three papers between 2018 and 2020, and the one specific idea each contributed — read from the papers rather than from the announcements.
10 min read
The Launch That Was Meant to Be a Research Preview
ChatGPT launched on 30 November 2022 on a model that was already public. What was new was the interface — and the growth figures need their sources.
9 min read
The Open-Weights Wave and How It Started
Open weights did not begin with the LLaMA leak in March 2023. The chronology from BERT to DeepSeek-R1, with each licence named.
10 min read
Symbolic AI and Connectionism: A Fifty-Year Argument
The intellectual history of the field's central disagreement, from a shared 1943 ancestor to the hybrid systems both sides now build.
11 min read
The Chatbots Before ChatGPT
PARRY, A.L.I.C.E., SmarterChild, Tay and the rest — what each one was built from and the specific thing each failed at.
10 min read
Ten AI Predictions That Were Confidently Wrong
Eleven dated predictions with their authors, what actually happened, and the two failure modes that account for nearly all of them.
11 min read
The Hardware Accident That Made Deep Learning Possible
How a chip designed to draw triangles for video games became the substrate for machine learning, with the arithmetic that explains why it fits.
11 min read
Other topics
- LLM fundamentals & architecture
- Tokens, tokenization & context windows
- Prompt engineering
- Reasoning models & test-time compute
- Multimodal AI: vision, audio, video
- RAG & retrieval
- Embeddings & vector search
- AI agents & tool use
- Structured output & function calling
- Fine-tuning & post-training
- Local inference errors, string by string
- Running local models day to day
- Testing code that calls an LLM
- Snapshot and property testing for model output
- Regression suites for prompts
- Eval gates in CI
- Flaky tests against a model
- Determinism and the cost of testing
- Contract and streaming tests
- Testing tool calls and retrieval
- Inference, serving & latency
- Rolling out a prompt change
- Testing AI systems in practice
- Forecasting a time series
- Machine learning on tabular data
- Geospatial data and models
- Understanding audio that is not speech
- Understanding video
- Core computer vision tasks
- Machine learning on graphs
- Point clouds and 3D
- Evaluation, benchmarks & LLM-as-judge
- Sensor and IoT data
- Logs and event streams
- Models over biological sequences
- Machine learning on molecules
- Embedding and searching code
- Extracting invoices and purchase orders
- Receipts, statements and tax forms
- Insurance policies and contracts
- Deeds, court filings and patents
- Extracting from medical records
- Observability & LLMOps
- CVs, certificates and identity documents
- Shipping, customs and technical documents
- Meetings, email, chat and filled-in forms
- Building an extraction pipeline
- Business, property and inspection documents
- Contract clauses and insurance claims
- Regulated and compliance documents
- Consumer, travel and closing documents
- Mapping one chat API onto another
- SDK and framework migrations
- Hallucination & failure modes
- Re-embedding and model deprecation
- Cutting over between providers
- Parity gaps, shims and legacy endpoints
- Moving between model versions
- Migrating vector stores and caches
- Mapping capabilities and parameters
- Migrating pipelines and agents
- Contracts, runbooks and rollback
- Auditing a codebase before a cutover
- Compliance and fine-tune migration
- LLM cost engineering
- Routing, cost tracking and multi-tenancy
- What a migration does to your prompts
- AI security & prompt injection
- Privacy, compliance & data residency
- AI governance, policy & society
- Building reliable AI applications
- AI hardware, GPUs & compute
- Open-weight models & local inference
- AI for developers & coding agents
- AI in industry: vertical playbooks
- AGI, superintelligence, alignment & the long future
- Machine learning foundations
- NLP fundamentals & classical tasks
- Data engineering for AI
- Synthetic data & dataset curation
- AI product design & UX
- Search, ranking & recommendation
- Enterprise adoption & change management
- AI careers, skills & teams
- Reading AI research
- AI in science & discovery
- Robotics & embodied AI
- AI economics, markets & business models
- AI myths, hype & media literacy
- Context engineering
- Shipping AI features: patterns & anti-patterns
- Build it: end-to-end AI tutorials
- Python for AI: hands-on recipes
- TypeScript, React and the web
- Frameworks and SDKs
- Errors and troubleshooting
- AI facts, numbers and statistics
- The maths behind AI
- Architectures beyond the transformer
- Reinforcement learning
- Diffusion and generative media
- Speech, audio and voice engineering
- Benchmarks, one at a time
- AI search visibility
- Infrastructure and operations
- Databases and storage for AI
- Knowledge graphs and structured knowledge
- Classical ML in production
- Regulation, jurisdiction by jurisdiction
- Prompt recipes and pattern library
- AI for people who do not write code
- Writing, media and creative work
- Edge and on-device AI
- Interpretability and model internals
- Field notes
- OpenAI model behaviour
- Claude model behaviour
- Gemini model behaviour
- Llama model behaviour
- Mistral model behaviour
- Qwen model behaviour
- DeepSeek model behaviour
- Cohere model behaviour
- Grok model behaviour
- Small model behaviour
- Hybrid model architectures
- Token cost by language and script
- Transliteration, romanization and script handling
- Locale-correct output
- Multilingual generation quality
- Multilingual pipelines
- The EU AI Act, article by article
- AI under the GDPR and EU data law
- US AI regulation, state and sector
- International AI governance and standards
- AI litigation and enforcement
- Running AI workloads on AWS
- Running AI workloads on Google Cloud
- Running AI workloads on Azure
- AI at the edge: Workers, Vercel and Netlify
- Serving models on Kubernetes
- Operating AI infrastructure
- Quantization formats and what they cost
- llama.cpp, flag by flag
- Ollama and the desktop local-model runtimes
- Local models on Apple Silicon
- Hardware for local inference
- Running speech and embedding models locally
- Model files, adapters and conversion
- VRAM arithmetic for local models