What AI actually is

Artificial intelligence is not one thing. It is a layered idea that runs from broad definitions down to very concrete techniques. Before you can apply it or sell it, you need to hold those layers clearly apart.

Artificial Intelligence (AI) is the overarching ambition: getting machines to do tasks we would normally say require human intelligence — reasoning, perceiving, language, deciding. Within that ambition sit narrower fields.

The four layers you always distinguish

• AI — the whole field, including classic approaches such as search algorithms, decision trees and expert systems that run on hand-written rules.
• Machine Learning (ML) — systems that are not explicitly programmed, but learn patterns from data. You give examples; the model works out the rules itself.
• Deep Learning — ML built on deep neural networks (many layers). This is the engine behind the breakthroughs since around 2012: image recognition, speech, language.
• Generative AI — models that create new content (text, images, code, audio) instead of only classifying or predicting. Chat assistants, image generators and coding helpers live here.

Two things people often confuse

Narrow AI vs. AGI. Everything running in production today is narrow AI: very good at one well-defined task. Artificial General Intelligence — a single system as flexible as a human across any domain — does not yet exist. Never sell narrow AI as AGI; that is the fastest way to break expectations.

Symbolic vs. connectionist. Early AI (the 1960s–80s) was symbolic: knowledge as explicit rules. The current wave is connectionist: knowledge as weights in a network, learned from data. Both have strengths and weaknesses — modern systems increasingly combine the two.

Core concepts and foundations

A handful of ideas form the vocabulary you need to follow any AI conversation — from a research paper to a sales pitch.

How a model learns

A model learns by turning data (examples) into parameters (the adjustable numbers, also called "weights"). During training those parameters are adjusted until the predictions are good. After that you use the model in inference: new input in, prediction out. Training is expensive and happens rarely; inference happens millions of times — that distinction shapes your cost structure later.

Three ways of learning

The trap everyone falls into: overfitting

A model that memorises the training data instead of the underlying patterns performs brilliantly on data it has seen and uselessly on anything new. That is called overfitting. The opposite — a model too simple to capture even the training data — is underfitting. The art is the balance: this is the bias-variance trade-off. That is why you always test a model on data it did not see during training.

How do you know a model is "good"?

With evaluation metrics. For classification you look at accuracy (how often you were right), but with imbalanced data that misleads — so you also use precision (of what you called positive, how much was right) and recall (of all true positives, how many you caught). For generative models, evaluation is harder and partly human judgement. Understand this: no model is 100% — the question is always "good enough for what?"

The technology under the hood

Now we go one layer deeper. You do not need to become a mathematician, but if you understand this mechanism, you immediately see why models can do what they do — and why they hallucinate.

The neuron and the network

A neural network is a stack of "neurons." A neuron is nothing magical: it takes numbers in, multiplies them by its weights, adds a bias, and pushes the result through an activation function that decides how strongly it "fires." One neuron is dumb. Millions of neurons in layers, together, form a function that can capture astonishingly complex patterns.

Learning = working errors backwards

During training you compare the prediction with the correct answer; the difference is the loss (the error). The algorithm then works out how each weight influenced the error and nudges each one a little in the direction that reduces it. This is called gradient descent, carried out through backpropagation. Repeat this billions of times over enormous datasets — that is "training."

From numbers to language: tokens & embeddings

A language model does not see words, but tokens (pieces of text) that it converts into embeddings: long lists of numbers that encode "meaning" as a direction in space. Words with related meaning sit close together. This is the trick that makes language workable as mathematics — and why models find connections we never explicitly programmed.

The breakthrough: the transformer & attention

Since 2017, almost all generative language AI runs on the transformer architecture. Its heart is attention: for every word the model weighs up which other words in the context matter most. That is how it grasps long-range connections in text. An LLM (Large Language Model) is essentially a giant transformer trained to keep predicting the next token — and it does this so well that language understanding, reasoning and code emerge from it.

And images, audio, video?

Image generators often use diffusion models: they learn to "de-noise" random noise step by step until an image appears that matches your prompt. Audio and video models use related ideas. The common thread: everything becomes numbers, a network learns the patterns, and generating is running the pattern in reverse.

Architecture: from model to working system

"Architecture" means two things. The model architecture (how the network is built — chapter 4). And the solution architecture: how you build a model into a product that works reliably, affordably and safely. The second is where most of the commercial value sits.

The ladder of control

There are four ways to make a model do your task, rising in effort and in grip:

1. Prompting — you instruct an existing model with good prompts. Fastest, no training. (Chapter 6.)
2. RAG (Retrieval-Augmented Generation) — you give the model relevant documents of your own as context, so it answers from your knowledge instead of guessing.
3. Fine-tuning — you train a model further on your own examples, so it truly internalises a style, format or task.
4. Training your own model — rarely necessary and very expensive; almost always start with 1–3.

RAG: why this is the workhorse architecture

RAG largely solves the hallucination and freshness problem. Instead of trusting what is in the weights, you first search your knowledge base for the relevant passages and paste them into the prompt. The search uses a vector database: your documents are turned into embeddings (chapter 4), and when a question comes in you pull out the semantically closest passages.

Agents: from answering to acting

An agent is an LLM that not only talks but is allowed to use tools: query a database, run code, send an e-mail, search the web. It works in a loop: think → choose an action → observe the result → think again, until the task is done. In 2025–2026 this is the fastest-growing area: agents that handle whole workflows on their own.

The trade-offs an architect makes

Every choice is a balance between four forces: quality, cost (per inference / per token), latency (speed) and privacy/control (where it runs, who sees the data). A bigger model is better but slower and more expensive. RAG raises quality but adds complexity. Fine-tuning lowers prompt costs but takes work up front. Good architecture = choosing deliberately, not "throwing the biggest model at it."

LLMOps: keeping it in production

Like any software, an AI system needs upkeep: monitoring of quality and cost, evaluation at every model switch, version control of prompts, and guardrails against misuse. This discipline is called MLOps / LLMOps and is where many projects fail in practice — building a demo is easy, keeping it reliable in production is not.

Using AI: the craft of prompting

Prompting is the steering wheel of a language model. The difference between a mediocre and an excellent result rarely lies in the model — almost always in the instruction. This is the most directly useful skill in the whole course.

Five principles that always work

• Be specific and give context. Say who the reader is, what the goal is, and what format you want. Vague in = vague out.
• Give a role and a frame. "You are an experienced tax advisor explaining to a beginner" steers both tone and depth.
• Show examples (few-shot). One or two good examples of input → desired output steer the model more powerfully than any description.
• Ask for steps (chain-of-thought). "Think step by step" or "explain your reasoning" noticeably improves quality on reasoning and calculation tasks.
• Specify the format. Explicitly ask for a table, JSON, bullet points or a maximum length. Structured output is immediately usable in software.

The anatomy of a strong prompt

Working with tools and data

Modern models can do more than text: they read images and documents (multimodal), call tools, and handle long contexts. The context window is what the model "sees" at once — prompt, attached documents and the running conversation together. Cramming in too much lowers quality; that is why focused context (RAG, chapter 5) beats "everything in."

Know the limits — or you sell thin air

• Hallucination: a model can produce convincing nonsense. Check facts; build in verification for important output.
• Knowledge cut-off: a model knows nothing after its training date, unless you give it current information via tools or RAG.
• No real sense of truth: it optimises for plausibility, not correctness.

Use cases: where AI pays off today

Theory only becomes valuable once you recognise the patterns where AI reliably pays off today. Remember the underlying shape — the same use case returns in every sector under a different name.

The pattern behind every good use case

AI pays off most where a task is (1) language- or pattern-driven, (2) high volume, (3) where "good enough + a human check" is acceptable, and (4) where time is expensive. Test every idea against these four. Does it score on all four? Strong candidate. Does it demand 100% accuracy with no supervision? Be careful.

The business of AI

Here we connect knowledge to money. First understand the value chain — because where you sit in the stack decides your margin, your risk and your defensibility.

The AI value stack

Value is earned on four layers. Higher in the stack = closer to the end customer, higher margin, easier to start, but also easier to copy.

Most founders and consultants earn their living on layers 3 and 4 — that is where the work can be done with knowledge rather than billions in capital.

Eight concrete business models

Pricing models — how you charge

• Per seat (subscription per user): predictable, familiar, easy to sell. Classic SaaS.
• Usage / credits (per consumption): tracks your own token costs and scales with use. Less predictable for the customer.
• Outcome-based (per result): paying per task handled or saving realised. A strong pitch, requires measurability. Rising with agents.

The numbers you must understand: unit economics

Every inference costs money (tokens in + tokens out). Your margin = what the customer pays − your token and infrastructure cost − support. A thin-margin wrapper with expensive tokens can run at a loss at scale. Do the sum in advance: cost per user per month vs. price per user per month. Many beautiful demos never became profitable because nobody did this sum.

Defensibility: why won't a competitor copy you?

The model is available to everyone — so it is not a moat. Your defence lies in: proprietary data, deep domain integration, workflow lock-in, brand & distribution, and network effects. Build your value there, not in "we use the newest model."

Risk, ethics and governance

Anyone deploying AI commercially carries responsibility and runs risk. Managing it is not a brake on your business — it is what makes you trustworthy and sellable to serious customers.

The core risks

• Hallucination: convincingly wrong output. Build in verification and source citation where it matters.
• Bias: models inherit prejudices from their training data. Test for fair outcomes across different groups.
• Privacy & GDPR: do not send personal data to services without a legal basis and a processing agreement. Know where the data goes.
• Copyright & IP: there is legal uncertainty about training data and generated output. Be careful with claims and commercial use.
• Security: new attacks such as prompt injection (malicious instructions hidden in the input) can mislead an agent. Limit what the tools are allowed to do.

Regulation: the EU AI Act

The European AI Act sorts applications by risk. The higher the risk, the stricter the requirements. Know this pyramid — it decides whether and how you may bring an application to the European market.

The working principle: human-in-the-loop

The practical golden rule: let AI make proposals, let a human decide on anything with serious consequences. This lowers your risk, satisfies much regulation, and is often simply better quality. "Human decides, AI accelerates" is a sellable promise; "AI decides autonomously about people" is a liability trap.

Applying it: your roadmap

The course ends where the real work begins. Here we turn everything into two parallel paths: deepening knowledge (educational) and turning that knowledge into income (commercial).

The educational path — keep building

• Learn by building. Pick one use case from chapter 7 and build a working prototype. Understanding follows from doing, not from reading.
• Specialise in one domain. You have breadth now; depth in one sector (your sector) makes you valuable and defensible.
• Learn in public. Write, share, explain. Teaching is the fastest way to deepen your own understanding — and it builds your reputation.

The commercial path — a 30·60·90 plan

The decision model for every idea

Run every idea through these four questions, in order: (1) Does the use case suit AI's strengths (chapter 7)? (2) Which architecture do I need — prompt, RAG or fine-tune (chapter 5)? (3) Which business model and which price (chapter 8)? (4) Do the unit economics work and do I have a moat? A "no" early in the list saves you months.

Closing, and where to go next

Test whether the through-line stuck. Then: curated resources to go deeper into every layer.

Further learning — curated resources