Seventy Years of Trying to Build a Mind
From wired relays to weighted layers
This walk through the field's history follows a single thread: every collapse traced back to hand-written knowledge hitting a wall it couldn't scale past, and every revival traced back to something making learning from data cheaper. The story opens with two thousand years of machines built to look autonomous while running entirely on wiring someone laid by hand — an Alexandrian engineer's automated theatre, a book of mechanical devices from the Islamic world, an eighteenth-century mechanical flute player and duck, a 1912 electromechanical chess machine that could play exactly one endgame and nothing else. Descartes, Leibniz, Babbage and Ada Lovelace all circle the same question before any computer exists, and Lovelace's objection — that the machine only does what it's ordered to perform — sets the limit the rest of the field tries to escape.
Alan Turing supplies the escape route: an abstract machine defining what any algorithm can decide, then a 1950 paper that swaps an unanswerable question about thinking for a measurable test, plus an unpublished 1948 sketch of machines that learn by adjusting their own connections. The name "artificial intelligence" arrives at the 1956 Dartmouth workshop, where a working program already proves theorems from a foundational mathematics text. The symbolic era that follows produces a checkers player that tunes its own evaluation weights, a pattern-matching therapist program, a robot that plans its own motor commands, and a conversational blocks-world system — all genuinely capable, all breaking the moment the world outgrows the rules a human wrote for it. Committee reports and funding cuts in 1966, 1970 and 1973 mark the first collapse, diagnosed as the same exponential explosion each time.
Expert systems bring the field back by narrowing to single domains — chemistry, blood infections, and a computer-configuration system that saves tens of millions of dollars a year — before the knowledge acquisition bottleneck and a hardware market collapse trigger a second winter. Meanwhile neural networks run their own quiet, mostly unfunded history from 1943 through Rosenblatt's physical, motor-adjusted perceptron, stalling when nobody can train middle layers, then reviving through backpropagation, convolutional networks, Bayesian probability, and support vector machines — none of which win until a labelled image database and consumer graphics cards make learning from data cheap enough, producing the 2012 result that resets the field. Attention-based architecture, scaling laws, reinforcement learning from human feedback, and tool-using agents carry the story to the present, closing on two warnings: progress here was never smooth, and old methods never got replaced, only rebalanced.
What's worth tracking now
Sits alongside a look at practitioner tools worth opening immediately: scikit-learn's own getting-started example, Andrej Karpathy's small automatic-differentiation engine for seeing backpropagation in miniature, Hugging Face's pipeline for pretrained models, hosted notebooks with free GPU access, and open coursework from Stanford and fast.ai. A closing note on hiring data shows AI-related skills appearing in a small but fast-growing share of job postings, with agent-related mentions up sharply and demand shifting toward people who can show real deployment work rather than theory alone.
Last time we ended with a list of words sorted out: artificial intelligence, machine learning, deep learning, statistics, data science. And we sorted them along one axis. On one side, rules a person writes down by hand. On the other, rules a machine works out from examples. The spam filter showed you both. First the hand-written version, with its growing pile of rules and its exceptions and its adversary who just spells the word differently. Then the counting version, which learned the same job from a labelled pile of messages and could be updated by recounting instead of rewriting.
Today we walk the history of the field. But I want to be clear about what kind of walk this is, because it changes what you should be listening for.
This is not a parade of inventions. If I hand you a list of clever machines in date order, you will remember maybe four of them and you will have learned nothing you can use. What I am going to do instead is walk the same axis we drew last time, forward through time, and show you that almost every boom and almost every collapse in seventy years happened at one particular place on it.
Here is the claim, stated plainly up front so you can test it against every era I describe. Every collapse in this story happened where hand-written knowledge hit scale and ran out of humans to write it. Every revival happened when something made learning from data cheaper: more data, better math, or faster hardware.
That is the whole chapter. Everything else is evidence.
And there is a small exercise I want you doing in your head the entire time. For each era, ask three questions. What did a human put into the machine? What did the machine have to work out for itself? And where did that arrangement break? Three questions, every era. If you do that, this stops being trivia and becomes a diagnostic tool you can point at any system you meet for the rest of your career, including the one you will build in a few phases.
Start well before computers, because the dream is much older than the hardware.
People have been building machines that appear to act on their own for about two thousand years. In the first century, an engineer in Alexandria wrote down designs for machines driven by air, water, and falling weights that performed sequences of theatrical motion — a little mechanical play that ran itself. Around twelve hundred, a polymath working in the Islamic world published a book of ingenious mechanical devices, including a boat of automated musicians floating on water, where the flow of water tripped cams that struck the drums. In the seventeen-hundreds, a French craftsman built a flute player that actually blew air, and a duck that appeared to eat, digest, and excrete, using copper weights, levers and rubber tubing. And in nineteen twelve, a Spanish engineer built an electromechanical chess player that could finish a game of king and rook against a lone human king, using electrical contacts and relays.
Apply the three questions to that chess machine, because it is the purest example of one end of our axis you will ever get. What did a human put in? Everything. The complete rule tree for that specific endgame, wired into relays. What did the machine work out for itself? Nothing at all. It executed. Where did it break? Immediately, the moment you changed the pieces on the board. It could not play any other position, because no human had wired any other position.
Underneath the machines, the philosophers were circling the real question. In the sixteen-thirties, Descartes argued that animal bodies were themselves complex automata — machinery, all the way down — but insisted that human speech and reason needed something immaterial, something no mechanism could supply. A generation later, Leibniz went the other way and proposed something that ought to make a programmer sit up: a universal symbolic language, and a calculus of reasoning, so that any human deduction could be reduced to calculation. Settle an argument by computing it. He also built a mechanical calculator, so this was not idle talk.
In the eighteen-thirties Charles Babbage designed a general-purpose mechanical computer controlled by punched cards. And in the eighteen-forties Ada Lovelace, annotating a description of that machine, made two observations that still frame the field. First, that the machine need not only handle numbers — it could manipulate any symbols, musical notes included, if you could encode them. Second, the objection now named after her: the machine has no pretension to originate anything. It does what we order it to perform.
Hold onto that objection. It is exactly the hand-written end of the axis, stated as a philosophical limit. And the entire history that follows is the field trying to get out from under it.
The escape route was drawn by Alan Turing, in two steps.
The first step, in nineteen thirty-six, was mathematical. Turing defined an abstract machine that manipulates symbols on an endless tape according to a table of transition rules, and used it to mark the boundary of what any algorithm can decide at all. That gave everyone afterward a precise object to argue about instead of a vague intuition about mechanism.
The second step, in nineteen fifty, was the one that mattered for our purposes. Turing published a paper in a philosophy journal and did something a working engineer should admire: he refused the unanswerable question. Rather than argue about whether a machine can think — a question where nobody can agree what the words mean — he replaced it with a test. Put a human interrogator at a text-only terminal. On the other end, a hidden human and a hidden machine. If the interrogator cannot reliably tell which is which, the machine passes. Notice what he did. He converted a metaphysical dispute into a measurable procedure with a pass condition. That move, converting an argument about meaning into a measurement, is the most transferable single habit in this entire history, and you will use it in Phase 1 the first time you have to decide whether a model is any good.
He also went through nine objections he expected and answered each one, including Lovelace's. And two years before that paper, in an unpublished report, he had already sketched the other end of our axis: machines he called unorganized, which start out with no arrangement and modify their own connection strengths through training. Learning from experience rather than instruction. Written down before the field even had a name.
The name arrived in nineteen fifty-six.
It came out of a grant proposal written the previous August by four people: a young mathematics professor at Dartmouth College named John McCarthy, Marvin Minsky, an information research manager at IBM named Nathaniel Rochester, and Claude Shannon from Bell Labs. They asked the Rockefeller Foundation to fund a summer research project at Dartmouth in New Hampshire, and it ran roughly eight weeks across that summer. McCarthy coined the phrase artificial intelligence in the proposal, in part to mark this off as its own thing rather than a branch of cybernetics or automata theory.
The proposal also stated the field's founding bet, and it is worth understanding rather than just admiring. The bet was that every aspect of learning, and every other feature of intelligence, can in principle be described so precisely that a machine can be made to simulate it. Read that again with our axis in mind. It is an enormously optimistic claim about hand-writing. It says: intelligence can be written down. If we are precise enough, we can specify it.
The attendees were formidable. Allen Newell and Herbert Simon came from Carnegie and the RAND Corporation, Arthur Samuel from IBM, Oliver Selfridge and Ray Solomonoff from MIT, Trenchard More from Princeton. And Newell and Simon did not just bring ideas, they brought a running program, written with Cliff Shaw in a language they had built for the purpose. It was called the Logic Theorist, and it proved thirty-eight of the first fifty-two theorems in the second chapter of a famous work on the foundations of mathematics. For one of those theorems it found a proof shorter than the one in the book.
Sit with that for a second, because it is a genuinely astonishing result for nineteen fifty-six, and it explains the confidence of the years that followed. A machine had done mathematics, and in one case done it better than the humans.
The era it launched is called symbolic AI, and it ran from the mid-fifties into the early seventies. The method was consistent. Represent knowledge as symbols and logical rules. Search through the possible combinations for one that reaches your goal. Newell, Shaw and Simon generalised the Logic Theorist into a program meant to solve problems in any domain, using a technique called means-ends analysis: look at the gap between where you are and where you want to be, pick an action that shrinks the gap, and recurse on whatever sub-problems that creates.
The achievements were real and varied. Arthur Samuel at IBM spent most of the fifties building a checkers program, and his write-up at the end of the decade is one of the founding documents of machine learning, because his program tuned the weights in its own board-evaluation formula based on how games actually went. At MIT, Joseph Weizenbaum built a program that imitated a particular style of psychotherapist using nothing but pattern matching and word substitution on the user's own sentences, and discovered to his discomfort that people confided in it and believed it understood them. Also at MIT, Terry Winograd built a system that held a real conversation in English about a simulated table of coloured blocks — it would move them on request, answer questions about why it had done things, and handle instructions that referred back to earlier ones. And at the Stanford Research Institute, a team spent six years building a mobile robot with a television camera, a range finder and bump sensors, which combined a planning system with a newly invented heuristic search algorithm to turn a high-level instruction into a sequence of motor commands.
Now the three questions, for the whole era at once. What did the humans put in? The symbols, the rules, the goal descriptions, and the structure of the world the machine operated in. What did the machine work out for itself? The search — which combination of the given rules reaches the goal. That is not nothing; searching a huge space cleverly is a real capability, and the blocks program really did chain deductions no human had written out individually. Where did it break?
It broke on the world. That conversational blocks program lived in a world of a few blocks with a few properties. The robot moved through a building specially arranged for it. Move to a world with a million things in it and the number of states to search through explodes, and the number of rules a human must write to describe it explodes too. And crucially, nobody had a way to make that second number smaller. More world meant more writing.
The first collapse came in the mid-seventies, and it came from three specific documents rather than a vague loss of interest.
In nineteen sixty-six, a committee convened by the American National Academy of Sciences examined machine translation and reported that it was slower than human translation, less accurate, and about twice as expensive. Federal funding for mechanical translation ended. In nineteen seventy, an amendment to a United States military authorisation act barred the defence research agency from funding basic research without direct military use, which cut off the open-ended grants that had sustained speculative laboratory work. And in nineteen seventy-three, a British mathematician named James Lighthill delivered a survey of the whole field to the Science Research Council. He divided it into three categories, and concluded that the middle one — building robots and the systems that would bridge theory to practice — had failed completely. His reason was precise, and it is our axis again in different words: the combinatorial explosion. The number of states to consider grows exponentially as you scale past miniature toy domains. The British government dismantled AI funding across its universities, keeping programs at only three: Edinburgh, Sussex, and Essex.
Notice what actually broke there. Not the logic. Not the search algorithms — that heuristic search from the Stanford robot is still taught and still used. What broke was the promise that these methods would scale out of the toy world, and the reason they could not was that scaling them meant hiring more humans to write more rules.
The field came back in the late seventies, and it came back by narrowing.
The insight was to stop building general reasoners and build systems that knew one specific thing extremely well. The pioneering work was at Stanford, on a project that encoded the heuristics of working organic chemists in order to deduce molecular structures from mass spectrometry data. Then in the mid-seventies, Edward Shortliffe built a system with roughly five hundred rules that diagnosed bacterial infections in the blood and recommended antibiotic doses. It even had a way of handling uncertainty — an improvised numerical calculus of certainty factors, invented because medicine does not deal in absolutes. Remember that improvisation; it will matter shortly.
Then the money arrived. In nineteen seventy-eight, John McDermott at Carnegie Mellon built a system, in a language designed for production rules, that configured computer systems. Digital Equipment Corporation deployed it in nineteen eighty to configure their minicomputers — working out which parts a customer's order actually needed, and which combinations would not work. It grew past two and a half thousand rules and handled tens of thousands of orders a year. The estimated saving was somewhere between twenty-five and forty million dollars annually in manufacturing and in technician time fixing bad configurations.
That is a real system, in production, making real money. Hand-written rules, at industrial scale, and it worked.
So stop here and do the exercise properly, because this is the era where the comparison with last chapter pays off. Take that configuration system and put it beside the spam counter we built. Both are doing the same abstract job: taking a case and producing a judgement. One has a human write two and a half thousand rules. The other has a human label some examples and lets arithmetic on word counts do the rest.
Now ask what happens to each when the world moves. A new computer part ships. Somebody must find every rule that touches the parts it interacts with, work out whether the new one changes them, and edit them without breaking the interactions with the other two thousand. That is a person, doing careful work, and the work gets harder as the rule base grows, because every new rule can interact with every existing one. Compare the spam counter when the spammers switch from "free" to a word meaning the same thing. You label the new messages and recount. The cost of an update does not grow with the size of what you have already learned.
That is the difference, and it is the whole reason one approach scaled and the other did not. The industry gave it a name at the time: the knowledge acquisition bottleneck. The bottleneck is human attention. There are only so many experts, they are expensive, and getting what they know out of their heads and into consistent rules is slow, unreliable work — half of what an expert knows, they cannot articulate.
The second collapse, in the late eighties and early nineties, had two causes, and only one of them is about knowledge.
The first was hardware, and it is a pure business story. Companies had built specialised machines whose microcode was tuned to run the symbolic programming language these systems were written in, and several vendors sold them. By nineteen eighty-seven, general-purpose workstations from Sun and ordinary personal computers built around a widely available thirty-two-bit processor beat those specialised machines on compute per dollar. The specialised hardware market collapsed almost at once. Commodity hardware improving fast enough to make your custom hardware pointless is a pattern you will see again, from the other direction, in about fifteen minutes of this story.
The second cause was the bottleneck arriving as predicted. The rule bases were brittle. Hand a system a case just outside its narrow domain and it did not degrade gracefully, it failed confidently, which is worse. Maintenance costs climbed. And funding followed: in nineteen eighty-seven the American defence research agency cut its AI programs after autonomous vehicle and battle-management milestones went unmet. Meanwhile Japan had launched an enormous national project in nineteen eighty-two, tens of billions of yen, to build massively parallel machines optimised for logic programming. It wound up in nineteen ninety-two without commercial traction, beaten by ordinary microprocessors.
Both winters, same diagnosis. Hand-written knowledge met the size of the real world.
While all this was happening, the other end of the axis had its own long, strange history, mostly out of the money.
In nineteen forty-three, Warren McCulloch and Walter Pitts showed that idealised networks of simple threshold units — fire if the incoming signal passes a level — could compute logical functions. In nineteen forty-nine the psychologist Donald Hebb proposed that a connection strengthens when the units on both ends fire together, which gave a mechanism for learning by adjustment. And in nineteen fifty-seven Frank Rosenblatt built the perceptron, publishing the model the following year. By nineteen sixty it existed in hardware: four hundred light-sensitive cells feeding a single layer of weighted connections, where the weights were physical potentiometers turned by small motors. The machine learned to classify visual patterns by adjusting its own weights. Not programmed. Trained.
In nineteen sixty-nine Minsky and Papert published a mathematical book about perceptrons that changed the field's direction. They proved that a single layer of these units cannot compute functions that are not linearly separable — the standard example being exclusive-or, true when exactly one of two inputs is true. They acknowledged that stacking layers should in principle fix this. But they also showed that at the time nobody had an efficient way to adjust the weights in the middle layers, the ones with no direct connection to the output. Funders read the proof and moved the money.
Which brings us to why the field's revival, when it came, was mathematical.
The middle-layer problem got solved. A paper in nineteen eighty-six by David Rumelhart, Geoffrey Hinton and Ronald Williams laid out backpropagation for multi-layer networks: compute the error at the output, then use the chain rule from calculus to push blame backward through the layers, so every interior weight learns how much it contributed. The idea had been analysed independently earlier — in a nineteen seventy-four doctoral thesis, and in work from nineteen seventy — but this is the paper that landed. Three years later, Yann LeCun and colleagues at Bell Labs applied it to reading handwritten postal codes, introducing convolutional networks, where a small pattern detector is reused across the whole image instead of learning each position separately. By the late nineties that line was reading cheques in production.
And the statistical turn happened alongside it. In nineteen eighty-eight Judea Pearl published the book that put reasoning under uncertainty on a rigorous footing, with directed graphs of variables and algorithms for propagating belief through them. Notice what that is: the honest version of those improvised certainty factors from the medical system. Same need, actual mathematics. In nineteen ninety-five Corinna Cortes and Vladimir Vapnik published support vector machines, which find the boundary with the widest possible margin between classes and use a trick to draw curved boundaries by working in a higher-dimensional space. They dominated benchmarks for the next fifteen years, beating neural networks. And in May nineteen ninety-seven, IBM's chess machine beat the world champion three and a half to two and a half, using four hundred and eighty custom chips searching up to two hundred million positions a second.
That chess result is worth a caution. It was a triumph of hand-built evaluation and enormous search, not of learning, and it was read at the time as a general milestone. Be careful with that kind of reading; we will come back to it.
So by the year two thousand the field had backpropagation, convolutional networks, rigorous probability, and support vector machines. And deep networks still mostly did not win. What was missing was not the idea.
What was missing arrived in two pieces. The first was data. A hierarchical image database of over fourteen million labelled photographs, organised by word meanings and labelled through crowdsourced human work, published in two thousand nine. The second was hardware, and here is that pattern from the other direction: consumer graphics cards, built to render games, turned out to be exactly the machines for the matrix arithmetic neural networks are made of.
In September twenty twelve, Alex Krizhevsky, Ilya Sutskever and Geoffrey Hinton entered a convolutional network into that database's annual competition. It trained on one point two million images across a thousand categories. Sixty million parameters, eight learned layers, and two engineering choices that mattered: a simpler activation function that does not flatten out and choke the gradient, and a technique that randomly drops units during training to stop memorisation. They wrote the convolutions themselves to run in parallel across two consumer graphics cards with three gigabytes of memory each, which brought training down to five or six days. Their error rate on the competition's five-guess measure was fifteen point three percent. Second place, using hand-engineered image features, got twenty-six point two.
That gap is not an improvement, it is a change of regime. And look at what actually moved. Not the axis — the network learned its own features from examples, exactly as the perceptron had aspired to. What moved was the price of learning from data. Millions of labelled examples became available, and the arithmetic got cheap enough to chew through them. Every revival in this story is that same sentence.
The next shift was architectural. In June twenty seventeen, a team at Google published a paper on sequence problems that threw out the two structural assumptions everyone had been using: the step-by-step recurrence of sequence networks, and the local neighbourhood focus of convolutional ones. Their architecture relies entirely on attention — each position looks across the whole context at once, comparing what it is looking for against what every other position offers, and pulling in a weighted mixture. Because nothing waits for the previous step, the whole computation becomes big matrix multiplications you can spread across a cluster of accelerators. That is what removed the bottleneck on long sequences, and every large language model you have used descends from it. We will take it apart properly in Phase 5.
Then the present. Once you could train on enormous text corpora without human labels — by hiding words and predicting them, or simply predicting the next one — the labelling cost that had gated everything went away. From twenty eighteen onward that produced two lineages, one built on filling in masked words and one on predicting the next token, and the second scaled dramatically: one and a half billion parameters in twenty nineteen showing surprising zero-shot ability, a hundred and seventy-five billion in twenty twenty learning tasks from examples inside the prompt. In twenty twenty a paper showed loss falls as a predictable power law in parameters, data and compute. In twenty twenty-two a follow-up showed the earlier models had been badly undertrained, and that parameters and training tokens should grow together. Reinforcement learning delivered its own results across the same decade: human-level Atari play, a Go champion beaten four games to one, and protein structure prediction from amino acid sequence.
Making those models usable took another step. Reinforcement learning from human feedback, formalised in twenty seventeen and applied to language models in twenty twenty-two, fits a model of human preference from pairwise comparisons and then optimises the language model against it, with a penalty for drifting too far from where it started. And the agentic present grew out of that: work in twenty twenty-two interleaving reasoning traces with actions and observations, work in twenty twenty-three teaching a model to call external tools like calculators and search, and a study that same year putting twenty-five generative agents in a shared simulated town with persistent memory, reflection and joint planning. That is the foundation for the autonomous frameworks in use now, and the fleet you will build in the capstone.
Two misconceptions to kill before we leave.
The first is that this was steady progress. It was not. It was lumpy, with long flat stretches where the good idea already existed and nothing happened, because the thing gating it was data or hardware or one missing piece of math. Backpropagation to the image-recognition breakthrough is twenty-six years. If you read this history as a smooth curve you will misjudge the next flat stretch, and you will misjudge the next jump too.
The second is that ideas die when their funding does. They do not. The probability that ran the statistical turn is the probability we teach properly in Phase 2, and those graphical models are on the syllabus set deliberately against the neural approach. Support vector machines get a full treatment in Phase 3. And hand-written rules never left production — go look inside a modern system and you will find rules doing guardrails, business logic, and the checks that catch a model's confident nonsense. Nothing here was replaced. The balance shifted.
The related pitfall, and the one that will cost you most as a practitioner: reading a demo as a capability jump. That chess match looked like general intelligence and was a very specialised search machine. A polished demo tells you what happened once, under conditions someone chose. A benchmark result on a public dataset with a stated method tells you more. Learning the difference is a skill, and the news segment of this show exists partly to practise it.
Which is why the course is shaped the way it is. Probability, optimisation and linear algebra are not detours we take to look serious. They are the tools this field discovered, repeatedly and expensively, that it could not win without: the chain rule is what unlocked the middle layers, probability is what replaced improvised certainty factors, and linear algebra is what let attention run on a cluster. Before we open any of that up, the next stretch gets a toolkit onto your machine and gets a model fit on real data, so the math has something to explain.
Tools worth opening this week
Now the perishable layer, and this pass is all practitioner tools. Each one gets what it is, why it matters to you specifically, and the smallest next action. Anything that depends on a version will move, so check the current one.
Start with the library you will meet first. Scikit-learn is the standard Python library for everything that is not deep learning: classification, regression, clustering, and the pipeline machinery that holds a workflow together. It matters because it is where your first trained model is going to live, in about as many lines as this sentence. The action is to open the official getting-started guide on the project's own site and run its short example end to end — load the iris flower dataset, standardise the features, fit a random forest, score it. Ten lines, and you will have done the whole workflow once before we name any of its parts.
For deep learning, the framework to learn is PyTorch, and it is the default across research and increasingly production. You do not need it yet. What you can do now is bookmark the one resource I would put above any tutorial: Andrej Karpathy's neural networks course, and its companion repository, a tiny automatic differentiation engine written in plain Python on single numbers. Clone that repository and step through its engine file and its demo notebook. It is a few hundred lines, and it is backpropagation — the nineteen eighty-six result — small enough to hold in your head. When we build backprop from scratch in Phase 4, you will have seen it.
For working with pretrained models, the Hugging Face transformers library is the reference, along with its model hub. The smallest possible action is three lines in a notebook: import their pipeline helper, ask for sentiment analysis, and pass it a sentence. It downloads a model and classifies your text. That is the off-the-shelf end of this show's rhythm, and it takes under a minute.
You need somewhere to run all of this. Google Colab and Kaggle Notebooks are both hosted browser notebooks with free graphics-card access, and either removes every installation excuse today. Locally, either JupyterLab or Visual Studio Code with its notebook extension is fine. We install the local stack next.
If you want structured coursework alongside this show, two open options are worth knowing. Stanford's machine learning course materials are freely posted and go at the mathematics. Fast.ai's practical deep learning course goes the other way, top down: their first lesson has you train an image classifier before explaining it. Run that first notebook.
One job-market note, because it should shape what you practise. Tracking of United States job postings finds AI skills named in about two and a half percent of all listings, with mentions of agent-related skills up more than two hundred and eighty percent year over year. In AI engineering postings specifically, Python appears in around seventy-one percent, Amazon's cloud in about a third, Microsoft's in about a quarter. Entry-level software openings have tightened, but demand has shifted toward people who can show production operations, pipeline work, and real fine-tuning. Read that as confirmation of the plan: the portfolio project at the end of each phase is the artefact, and deployment is not an optional final chapter.