Cursus

Math

advanced

Convex Optimization: From Gradient Descent to Interior Point Methods

The real divide in optimization is convex against nonconvex, and it decides whether you can prove your answer is best or merely hope so. Start by learning to recognise convexity without touching a Hessian. Derive why the safe step size is one over the smoothness constant, and why the condition number governs everything. Pick up duality and the KKT conditions as your certificate. Then add curvature, and see how a log barrier turned constrained problems into something solvable in polynomial time.

Science

intermediate

Microbiology: the cell that plays by different rules

Bacteria share almost no structure with your cells, and every difference matters. Work through the bacterial envelope and genome, then the arithmetic of exponential growth and why a plate count lies to you, then how antibiotics exploit those differences and how resistance defeats them, and finally how sequencing reads the vast majority of microbes nobody can grow. You will finish able to read a growth curve, work a viable count, and explain why a resistant infection is a population event rather than a patient one.

AI

advanced

Deep Learning on Limit Order Book Data

At a one-event horizon, 92 percent of mid-price labels are exactly no-change, so a model that always predicts flat scores 92 percent accuracy. That single number explains most of the gap between published order book results and what happens on a trading desk. This path covers what the book actually contains, what the architectures assume, why results fail to replicate, and the cost hurdle that decides whether a real edge is worth anything.

AI

advanced

Reinforcement Learning for Trade Execution and Market Making

A classical execution schedule is an open-loop policy: it commits to a plan before seeing anything, and reinforcement learning's entire value here is closing that loop. This path measures what closing it is actually worth, shows how a mis-sized penalty makes leaving part of the order unexecuted rationally optimal, and demonstrates that one unverifiable queue assumption moves the simulated fill rate by a factor of two. Every figure is computed.

AI

advanced

Financial Machine Learning: Building a Dataset That Does Not Lie

Shuffled cross-validation reports 54 percent accuracy on market data containing no signal whatsoever, and that number is why competent machine learning so often fails on markets. This path fixes the dataset rather than the model: labels that describe trades someone would actually place, features that are stationary without being amnesiac, and a validation scheme that returns chance when there is nothing there. Every figure in it is computed and reproducible.

History

intermediate

How the Industrial Revolution Actually Happened

Machines that were technically feasible in several places were adopted in one of them, and explaining that is still argued about. This path sets out the competing answers and what each rests on, follows the steam engine from a mine pump to a portable prime mover, explains why work moved out of houses and into buildings, and works through the revised numbers showing that output per worker outran wages for roughly fifty years.

Science

intermediate

Materials Science: Why Things Break

A perfect copper crystal should yield at 7 GPa and real copper gives way at 10 MPa, and closing that gap took thirty years and produced most of modern metallurgy. This path builds mechanical behaviour from defects: dislocations that let metals bend and ceramics shatter, cracks that make a part fail far below its yield strength, and the material index that ranks candidates for a job instead of ranking them in the abstract.

Math

advanced

Group Theory and Symmetry

A group is a set with one operation and four rules, and that deliberate poverty is what lets a single theorem cover rotations, shuffles, clock arithmetic and Rubik's cube at once. This path starts from the symmetries of a square, proves Lagrange's theorem and gets Fermat's little theorem for free, shows why no crystal can have five-fold symmetry and what happened when one did, and ends with the group of order 60 that makes a quintic formula impossible.

Math

intermediate

Discrete Mathematics: Counting, Proof, Graphs, and Congruence

The mathematics of finite structures sits under most of computing, and it is usually absorbed in fragments rather than learned. This path builds four working tools: counting arrangements you could never enumerate, proving a claim for every input instead of the ones you tested, modelling relationships as graphs and reading what the structure permits, and doing arithmetic on a circle. Every result is tied to something engineers actually hit.

Math

intermediate

Signal Processing: Fourier, Sampling, and Filters

Audio, images, sensors and instruments all rest on the same four ideas, and getting any of them wrong destroys data silently. This path builds the frequency domain and why sinusoids get the job, the sampling rule that cannot be broken and what aliasing does when it is, convolution and the filters built from it, and how to read a spectrum without mistaking the analysis for the signal. Every number is computed, so you can reproduce it.

Math

intermediate

Calculus for Machine Learning

Derivatives, gradients and the chain rule are the machinery under every training run, and knowing them changes what you can debug. This path builds the derivative as a local linear model, then gradients, Jacobians and Hessians, then the chain rule as a product whose evaluation order decides the cost, and finally automatic differentiation itself. You will finish knowing why a billion-parameter gradient costs one backward pass, why conditioning sets your iteration count, and where autodiff answers the wrong question exactly.

Programming

intermediate

Performance Profiling: Finding the Bottleneck That Matters

Most optimisation effort goes into code that was never the problem, because intuition about where time goes is reliably wrong. This path builds the discipline instead: the arithmetic that caps what any optimisation can buy, how profilers work and how to read a flame graph, the six causes behind almost all real slowness, and how to benchmark honestly and recognise the point where optimising stops paying.

Programming

intermediate

Deployment Strategies: Shipping Without Breaking Things

A deploy replaces a working system with a different one while people are using it. This path covers how teams make that routine: the four strategies as answers to how many users meet a bad version, canary releases as controlled experiments, feature flags separating deploy from release, and the compatibility discipline that decides whether the rollback you are counting on actually works.

Programming

beginner

The AWS Ecosystem: A Map of the Platform

AWS lists hundreds of services, which makes it look like a catalogue to memorise. It is not. This path gives you the scaffolding everything else hangs from: the geography of regions and availability zones, accounts and IAM as your blast radius, the compute spectrum from machines to functions, the three shapes of storage and how to choose a database, and the network layout that quietly decides your bill.

AI

intermediate

AWS Bedrock and AgentCore: Agents as Managed Infrastructure

Running one agent is a while-loop around a model call. Running hundreds, for real users, with real credentials and real consequences, is infrastructure. This path covers what AWS provides at each layer: Bedrock's one door to many models, the runtime that isolates every session, the gateway that turns your existing APIs into agent tools, and the memory, identity and tracing that decide whether an agent survives production.

Programming

intermediate

Testing Strategy: What Is Worth Testing

Tests are a purchase, not a virtue: you spend writing time, run time and maintenance time to buy confidence about specific breakages. This path works out how to spend that budget. What each level of test can and cannot catch, how test doubles buy speed by trading away fidelity, how property-based testing finds the inputs you would never have imagined, and why flakiness destroys a suite faster than any missing test.

Business

advanced

A/B Testing at Scale: The Experimentation Platform

The companies that test everything do it because their own data showed most confident product ideas fail. This path builds the experimentation machine: randomisation and the plumbing that keeps it honest, the sample ratio check that catches broken experiments, the peeking trap and the sequential designs that fix it, and the advanced layer, CUPED variance reduction and the interference problems where arms contaminate each other.

AI

intermediate

Recommender Systems: The Two-Stage Machine

No model ranks the whole catalogue: a cheap retrieval stage cuts millions of items to hundreds, an expensive ranker orders those hundreds, and the trap nobody warns you about is that the model trains on clicks it caused. This path builds the architecture, the two-tower geometry of taste, the objective functions that encode what a product values, and the feedback loops and exploration budgets that decide what the system becomes.

Computer Science

intermediate

Search Relevance: From BM25 to Hybrid

Vector search did not replace keyword search; production search runs both, because they fail in opposite places. This path builds relevance engineering from the ground up: the inverted index and the analysis decisions baked into it, BM25 and its saturation arithmetic, hybrid retrieval with reciprocal rank fusion, and the evaluation machinery, judgment sets, NDCG, position bias, that tells you whether any of it actually got better.

Programming

intermediate

Observability: Knowing Why Production Is Slow

Monitoring answers the questions you wrote down in advance; production fails in ways you did not. This path builds observability from its raw materials: the three telemetry signals and their very different bills, the percentile and cardinality arithmetic that decides what your data can honestly say, tracing and the craft of throwing spans away, and the SLO machinery that turns reliability into a number a team can actually spend.

Business

intermediate

Card Payment Rails: What Happens When You Tap

The tap is instant. The money is not. Card payments run on a machine most engineers never see: four parties exchanging promises in a second and settling cash days later in netted batches. This path maps who touches every transaction, the three clocks a payment runs on, the fee structure that quietly shapes entire business models, and the failure paths, declines, 3-D Secure and chargebacks, where payments work actually lives.

AI

intermediate

MLOps: Keeping a Model Working After You Ship It

Training a model is the part that works. The system around it is what decays, and it decays quietly: no exception, no alert, just answers that are slowly less right. This path covers what actually breaks. Why changing one feature moves every weight, the three levels of automation and which one you need, the skew between training and serving that no isolated test can see, and the monitoring that decides when a model has stopped earning its place.

AI

intermediate

FiftyOne: Curating Computer Vision Datasets You Can Actually See

Most vision projects are limited by their dataset rather than their architecture, and most teams cannot see their dataset. A hundred thousand images in a folder is not something you can inspect, so problems that would be obvious in ten minutes of looking go unfound for months. This path covers the tool built for that: the data model that makes a dataset queryable, views as chained questions, the analysis methods that rank where to look, and evaluation that turns a metric back into the images behind it.

AI

advanced

How Voice Models Work: Tokens, Recognition, and Synthesis

One minute of talking is about 195 tokens as text and about 36,000 as audio. That ratio explains almost every design decision in speech systems, and this path starts there. How neural codecs turn a waveform into something a transformer can model, why speech recognition has three architectures rather than one and which of them can stream, how treating audio as tokens made cloning a voice from three seconds possible, and what the standard speech-to-text-to-speech pipeline throws away that it can never get back.

AI

intermediate

The Illusion of Thinking, and the Rebuttal That Followed

Apple researchers ran a careful experiment on whether reasoning models reason, found accuracy collapsing to zero past a complexity threshold, and the result travelled fast. Then a response appeared that disputed none of the data and argued the experiment measured something else: models were being asked to print answers longer than their output limits, some puzzles had no solution at all, and asking for a program instead of a move list restored accuracy on the same instances. This short path follows both, and ends with the rules for measuring anything.

AI

intermediate

A Definition of AGI: What Happens When You Actually Try to Measure It

AGI anchors company charters, national policy and enormous investment, and until recently nobody had an operational definition of it. A 2025 paper with more than thirty authors proposes one, by borrowing the framework psychology spent a century validating and scoring machines against all ten of its cognitive domains. The totals make headlines. The profile is more interesting: current systems are at full marks on some domains and at exactly zero on the ability to form a new long-term memory.

AI

intermediate

The Era of Experience: Reading Silver and Sutton's Argument

The man who wrote the textbook on reinforcement learning and the man who led AlphaGo published a short paper arguing the field has taken a wrong turn. Training on human data, they say, makes human performance the target by construction, and the next capability jump requires agents that learn from what actually happens instead. This short path takes the argument seriously: the three eras, the four things an experiential agent would do differently, and the published critique that its answer to safety does not yet work.

AI

advanced

FlashAttention and the Art of Finding the Real Bottleneck

For five years attention was optimised by cutting FLOPs, and the faster algorithms kept not being faster. They were solving the wrong problem: attention spends its time moving a matrix between GPU memory tiers, not computing. This path follows the diagnosis and the fix, from the memory hierarchy through the rescaling identity that lets softmax be tiled, to writing fused kernels yourself, and ends where the same signature shows up next: normalisation, the optimizer step, and the logits tensor nobody thinks about.

AI

advanced

Beyond Attention: Linear Attention, State Space Models, and Hybrids

At a million tokens a transformer's KV cache is 344 GB. A recurrent state doing the same job is 16.8 MB, and constant at any length. This path explains how that is possible and what it costs. Delete the softmax and attention becomes a recurrent network you can still train in parallel. Start instead from control theory and you arrive at the same object, which is the result Mamba-2 made precise. Then the honest part: a fixed state has fixed capacity, exact retrieval is what breaks first, and a few attention layers buy most of it back.

AI

advanced

Synthetic Training Data: Generating It Without Poisoning the Model

Generating 50,000 training examples costs roughly a thousandth of annotating them, and cheapness is the least interesting thing about it. What decides whether the result works is a set of properties nobody notices until the model is trained: whether the generator holds the information at all, whether a checker can lift the ceiling above it, whether the dataset covers its input space or repeats one example, and whether the real data ever leaves the mix. This path builds the pipeline that survives all four.

AI

advanced

Constrained Decoding: Output That Always Parses

A 5 percent JSON failure rate does not double your average latency, it doubles your p95. Constrained decoding removes the failure entirely by editing the logits before sampling, so invalid tokens have probability exactly zero. This path builds the mechanism from the decoding loop outward: how a schema compiles into an automaton and then into a per-token mask, why recursive grammars need a stack and how that cost is made near-free, and the part most teams get wrong, that a badly ordered schema constrains the reasoning as well as the output.

AI

advanced

Distributed Training at Scale: FSDP, Tensor and Pipeline Parallelism

Mixed-precision Adam costs 16 bytes per parameter, so a 70B model needs 1120 GB of state before a single activation is stored. Getting that onto real hardware, and keeping the run alive while a component fails every three hours, is the skill behind every frontier model. This path builds it: where the memory actually goes, how ZeRO and FSDP shard what data parallelism duplicates, how tensor and pipeline parallelism split the computation itself, and what makes a fifty-day run finish.

AI

advanced

Quantizing LLMs: From 16 Bits to 4 Without Breaking the Model

A 70B model is 140 GB at 16 bits and fits on no single accelerator. At 4 bits it is 36 GB, runs about four times faster per token, and leaves most of the card free for KV cache. Getting there without wrecking the model is a specific, teachable skill. This path builds it from the arithmetic up: what quantization does to a number, why large transformers grow activation outliers that break naive methods, how GPTQ and AWQ use calibration data, and how to measure the damage honestly before you ship.

Law & Compliance

advanced

Product Liability for Software: The 2024 Directive

For forty years it was arguable that software was not a product, and therefore not covered by strict liability. Directive (EU) 2024/2853 ends that argument, applies to products placed on the market from 9 December 2026, and reaches cloud services a device depends on. It also lets courts order disclosure of your evidence and presume defectiveness when complexity makes proof excessively difficult. This path follows the Directive: what is now a product, what counts as a defect, who pays for what, and how a claim is proved.

Law & Compliance

advanced

The EU Cyber Resilience Act: Building Products Under Product Law

From 11 September 2026, manufacturers must report actively exploited vulnerabilities in their products within 24 hours. From 11 December 2027, software and connected hardware carry a CE mark for cybersecurity. Regulation (EU) 2024/2847 places connected products under the same machinery that governs toys and lifts, and most engineering teams have never worked under product law. This path follows the Regulation itself: what it covers and whom it binds, what Annex I demands of the product and of the manufacturer, how the reporting clocks run, and what evidence survives an inspection.

AI

advanced

LLMs in Trading: What the Evidence Actually Supports

Language models are poor at the job they are advertised for and genuinely good at one nobody mentions: turning unstructured text into structured data at a scale that was never affordable. This path locates them against the trading stack, then confronts the defect that makes almost every published result hard to read, since a model trained on the backtest period may already know what happened and uses that knowledge even when told not to. It reads the leading study qualifier by qualifier, and ends with the engineering and governance that survive an audit.

Programming

advanced

Kubernetes: Orchestration as a Set of Control Loops

Kubernetes looks like a pile of object types until you notice it is one idea repeated. Store a description of the desired state, and run loops that compare it to reality and act on the difference. Because those loops read the current state rather than react to events, missed and duplicated messages are harmless and an interrupted controller simply resumes. This path builds the loop, shows every object as a controller joined by label matching, covers the two resource numbers that drive most cost and latency bugs, and ends with the failures the design itself creates.

Programming

advanced

Containers From First Principles

There is no container object in the Linux kernel and no container system call. A container is an ordinary process with several isolation features switched on, all of which predate the technology by years. So the thing that actually changed practice was not the kernel: it was an image format that is immutable, content-addressed and shippable, built on the same idea as Git's object store. This path covers the primitives, the format and its consequences, where data and traffic have to go, and the honest answer on how much the isolation is worth.

Programming

advanced

Git Internals: The Model Under the Commands

Git's command line has a deserved reputation, and the data model underneath is small and regular. It is a content-addressed store of four object types, plus a set of files holding hashes. This path derives the object hash by hand, shows that a branch is a forty-character file, explains what a three-way merge actually computes and why rebase creates new commits rather than moving them, and ends with recovery. Every command turns out to add objects or move a pointer.

Programming

advanced

Go: Goroutines, Channels, and What Was Left Out

A thread costs enough that programs are architected around not having many. A goroutine costs little enough that the constraint disappears, and the designs that become available are the point. This path builds the scheduler that makes them cheap, the channels that let them coordinate without shared memory, and the leak that is the characteristic Go bug because nothing stops a goroutine but its own return. It ends on the omissions: no exceptions, no inheritance, no formatting choices, and what each one trades.

Programming

advanced

Rust: Ownership, Borrowing, and What They Buy

Every language decides who frees memory and when, and Rust decides it at compile time from one rule: each value has exactly one owner. This path builds that rule, then the borrowing discipline that lets values be lent without transferring them. The payoff arrives in the third lesson, where data races turn out to be compile errors for free, because a race is aliasing plus mutation and the checker already forbids that. It ends on the escape hatches and where the guarantee genuinely stops.

Computer Science

advanced

Formal Verification: Proving a Program Correct

Testing samples inputs; a proof covers all of them. Three traditions do this and each hits a different wall. Deductive proof turns a program into a relation between assertions, and stalls at the loop invariant no machine can supply. Type-level encoding makes wrong programs unwritable, and pays with a language that rejects some correct ones. Model checking searches every state exhaustively, and is bounded by how many there are. The path ends with two systems that were actually verified, and what they cost.

Computer Science

advanced

Floating Point: Why Your Numbers Are Wrong

Every floating point operation is correctly rounded to about sixteen digits, and results are still wrong in the first digit. This path explains how both are true: the guarantee is per-operation and relative, which means subtracting nearly equal numbers promotes error from insignificant to dominant without introducing any. It covers the representation, the cancellation patterns worth recognising, how to compare and test, and finally how to tell whether an inaccurate answer is your bug or the problem's nature.

Computer Science

advanced

Probabilistic Data Structures: Answers Without the Data

Answering set questions exactly costs memory proportional to the data, and that is a lower bound rather than an inefficiency. Sketches give up exactness in a specific, chosen direction and get constant memory in return. This path builds the three that run modern infrastructure: Bloom filters for membership, HyperLogLog for distinct counts in twelve kilobytes, and count-min for frequency. It ends on the property that actually explains their ubiquity, which is not the space saving.

Business

advanced

Clearing and Settlement: The Half Nobody Watches

A trade is agreed in microseconds and completed days later, and in between both sides hold a promise rather than an asset. This path covers the machinery that closes that gap: novation, which replaces a stranger's creditworthiness with one institution's, the default waterfall that institution burns through when a member fails, and the delivery mechanics that make losing your money outright impossible. It ends on an honest accounting of where the risk actually went.

Business

advanced

Trade Execution: Working an Order Without Giving It Away

The cost of a trade is not the commission and not the spread. It is the gap between what the decision would have earned on paper and what the account actually got, and the largest component is often the shares that never traded. This path builds implementation shortfall, then the scheduling optimisation that trades impact against timing risk, then the placement decisions underneath every slice. It ends on why execution quality is far easier to produce than to prove.

Business

advanced

Trading Risk: Measuring It, and Surviving It

Value at Risk compresses a loss distribution into one number, and there is an arithmetic case where it reports that diversification made things worse. This path builds that failure and the coherence axioms explaining it, then attacks the deeper problem: the distribution itself is estimated and wrong in known directions that all understate danger and all fail together. Leverage turns those errors into forced exits. Sizing is the only decision that changes an outcome, and its arithmetic is unforgiving.

Business

advanced

Options and Volatility: Pricing Without Forecasting

An option's value at expiry is arithmetic. Before expiry it looks like it needs a forecast of the underlying, and the central result of the subject is that it does not. This path builds put-call parity, which needs no model at all, then the replication argument that cancels direction and leaves volatility as the only thing being traded. The greeks decompose what a hedged position still carries, and the volatility surface turns out to be the market correcting the model in the model's own units.

Business

advanced

Market Microstructure: Where a Price Comes From

No exchange quotes a price. It sorts other people's orders and matches them, and every number on a trading screen is the residue of that process. This path builds the limit order book and its matching rules, then answers the question the mechanism leaves open: why competition does not compress the spread to zero. The answer, that a trade is evidence, then explains price impact, the capacity ceiling on any strategy, and why market design decides who profits.

Computer Science

advanced

Computer Graphics: Rasterisation and Ray Tracing

Every renderer answers one question first: at this pixel, which surface is visible? There are two ways to answer it, and almost everything else about a graphics system follows from which one it picked. This path builds the transform chain, then rasterisation as a distributed sort with a depth buffer, then ray tracing as a search through a spatial hierarchy. The last lesson explains why the two coexist, and lets you predict which effects will be cheap, which will be faked, and what the artefacts will look like.

Computer Science

advanced

The Limits of Computation: What No Program Can Do

Some things are not slow to compute, they are impossible, and the boundary is sharp enough to prove in a few lines. This path climbs the ladder of machines one memory model at a time: finite states and the counting argument that defeats them, then a stack, then an unbounded tape. At the top the limit stops being about memory and becomes the halting problem, generalised by Rice to every semantic property at once. The last lesson spends that result on why every type checker and verifier must choose which way to be wrong.

Computer Science

advanced

Dynamic Programming and Greedy: Knowing Which One Applies

Both techniques replace exponential search with something polynomial, and both fail on problems without the right structure. This path builds the recognition skill rather than a catalogue of recurrences: optimal substructure and where it breaks, choosing a state and deriving the running time from it, the exchange argument and the matroid theorem that says exactly when greedy is guaranteed, and a decision procedure to run on a problem you have never seen before.

Business

advanced

Backtesting: Why Most Profitable-Looking Strategies Are Not

A backtest decides which trading strategies get capital, and it is the most misleading artifact in quantitative finance. This path explains why: a backtest is a counterfactual rather than a measurement, mechanical biases like look-ahead and survivorship all inflate it in the same direction, and selecting the best of many trials produces an impressive result even when nothing works. Covers the deflated Sharpe ratio, the probability of backtest overfitting, why costs scale with size and impose a capacity ceiling, and a research protocol whose output you can actually believe.

AI

advanced

Causal Inference: From Correlation to Consequence

Every model whose output drives a decision is answering a causal question, whatever it was trained on. This path builds the machinery that makes those questions answerable: structural causal models and the three ways variables become associated, the identification results that say exactly when observational data suffices and by what formula, the hard limit on learning a graph from data, and where invariance across environments turns causal structure into a training signal.

Robotics

advanced

How Robots Walk: Central Pattern Generators

Walking is rhythmic, fast, unstable, and made discontinuous by every footfall, which is why trajectory planning fits it badly. Biology solves it with spinal circuits that generate rhythm without the brain. This path builds that architecture: coupled phase oscillators whose limit cycles absorb disturbances, gaits as nothing more than sets of phase relationships, the salamander robot where one scalar drive switches swimming to walking, and how sensory entrainment and reinforcement learning compose with it.

Computer Science

advanced

Differentiable Rendering: Running Graphics Backwards

If a renderer is differentiable, recovering a 3D scene from a photograph becomes gradient descent. This path builds that idea properly: the rendering equation and why Monte Carlo path tracing is the only way to evaluate it, the visibility discontinuities that make naive autodiff return silently zero gradients for geometry, the adjoint and path-replay methods that made the backward pass affordable, and why the remaining difficulties are about the problem being ill-posed rather than about the gradients.

Robotics

advanced

Predicting Human Motion: Socially-Aware AI

Any machine sharing space with people must answer one question continuously: where will they be in five seconds? This path builds human trajectory forecasting from the problem statement to deployment: why the answer is a distribution rather than a path, the social pooling layer that let networks learn collision avoidance nobody programmed, why the field's standard metric rewards predicting a walk into a wall over a plausible wrong turn, and the four gaps that separate a benchmark number from a robot that is safe around people.

Math

advanced

Optimization on Manifolds: When Parameters Live on a Curve

Rotations, subspaces, low-rank matrices and covariances are not vectors in flat space, and treating their constraints as penalties throws away structure that makes the problem easier. This path builds Riemannian optimization from the ground up: tangent spaces and the metric that decides what steepest means, the projection that turns an ordinary gradient into the right one, retractions that let you move along a curved space without solving differential equations, and why these non-convex problems are so often solved to global optimality anyway.

AI

advanced

Federated and Decentralized Learning

Hospitals, phones and banks hold the data that would train the best models, and none of them are allowed to share it. This path builds the field that trains on data you never see: the FedAvg round structure and why local steps are the communication lever, the client drift that heterogeneous data causes and the control variates that correct it, gossip protocols that remove the server entirely and the spectral gap that governs them, and what model updates actually leak once someone attacks them.

AI

advanced

Easy, Hard, Impossible: Phase Transitions in Learning

When your model fails, are you short of data or short of computation? Those look identical from the outside and have completely different fixes. This path builds the statistical physics of computation, the field that made the distinction precise: planted models and the high-dimensional limit, the three-phase structure where information can be present while every efficient algorithm fails, the message-passing algorithms that reach the computational limit and predict their own error exactly, and what genuinely transfers to deep learning.

Business

advanced

Algorithmic Pricing and the Collusion Question

Independent pricing algorithms, given nothing but a profit signal and no way to communicate, learned to charge high prices and punish each other for undercutting. Nobody programmed them to. This path builds the mechanics of pricing software from revenue management to reinforcement learning, works through the simulation results that started the field and the punishment strategies they uncovered, weighs the German fuel-market evidence against serious arguments that the findings are fragile, and ends at a legal system built to catch people agreeing in rooms.

Business

advanced

Synthetic Consumers: Can an LLM Replace a Survey Panel?

Language models can answer survey questions in the voice of any demographic, instantly and at almost no cost. Marketing science has spent three years asking whether the data is any good, and the answer is more interesting than yes or no. This path builds the method from its founding results, algorithmic fidelity and homo silicus, through the documented failure modes of flattened variance and wrong-signed estimates, to the reproducibility problem where defensible setup choices moved correlations from .23 to .84, and the two failure modes that survive perfect methodology.

AI

advanced

Mechanistic Interpretability: Reverse-Engineering Neural Networks

Attribution methods tell you which inputs mattered. Mechanistic interpretability asks the harder question: what algorithm is the network actually running? This path builds the field from its foundations, why individual neurons are the wrong unit and what superposition says is really happening, through the circuits that implement in-context learning, the sparse autoencoders that pulled 34 million features out of a production model, and the causal interventions that separate a tested claim from a plausible story.

AI

advanced

Diffusion Language Models in Depth

A technical deep dive for anyone who already knows that diffusion language models generate text by iterative unmasking and wants to know how they are actually built. This path covers the formal machinery: categorical transition matrices and the variational bound that reduces to weighted masked language modelling, the from-scratch and checkpoint-adaptation training routes that carried the paradigm to 8 billion parameters, the approximate caching and confidence-aware decoding that finally made serving competitive, and the multimodal, safety, and evaluation problems that remain open.

AI

advanced

Submodular Optimization: Diminishing Returns with Guarantees

Choosing the best subset under a budget is usually intractable, unless the objective has diminishing returns. That property is submodularity, and it turns hard selection problems into ones a simple greedy algorithm solves near-optimally. This path builds it from the definition and its convexity analogy, through the celebrated (1 - 1/e) guarantee of Nemhauser, Wolsey, and Fisher, to sensor placement, influence maximization, and summarization, and finally the wider landscape of minimization and non-monotone problems.

AI

advanced

Computational Linguistics: The Formal Science of Language

How much computational power does human language actually require, and what can a neural network trained on it really compute? This path answers both with one tool. It builds the levels of linguistic structure and why language resists naive modelling, the Chomsky hierarchy that classifies grammar power, the finite-state methods that make morphology a solved problem, and the modern results placing RNNs and transformers on that same ladder. Grounded in the landmark results of Chomsky, Shieber, and the formal theory of language models.

AI

advanced

Bayesian Optimization: Tuning Expensive Black-Box Functions

Some functions cost hours or dollars to evaluate once and give no gradient, so you must find their optimum in as few tries as possible. This path builds the standard method for that: why grid and random search waste the budget, how a Gaussian process predicts the objective and its uncertainty everywhere, how acquisition functions like Expected Improvement and the no-regret GP-UCB of Srinivas, Krause, Kakade, and Seeger decide where to look next, and how the tools work in practice. Grounded in the landmark papers of the field.

Computer Science

intermediate

Core Data Structures: Hash Tables, Trees, Heaps, and Tries

Four structures cover most of what production code actually needs, and each exists because the others cannot answer one particular question. This path builds them from the mechanism up: why a hash table's constant lookup costs you all ordering, why sorted input destroys an unbalanced tree and what a rotation repairs, why a heap keeps only enough order to surface the smallest item, and why routers and autocomplete need a trie. You will finish able to pick the right one from the question being asked.

Computer Science

intermediate

How CPUs Actually Work: Pipelines, Caches, and Performance

Two processors at the same clock speed can differ several-fold in real work done, and the reason is never the clock. This path builds the model that explains it: how a pipeline overlaps instructions and what a mispredicted branch costs, how a core issues several instructions per cycle and reorders them, why a DRAM access is roughly sixty times an L1 hit, and how the roofline model tells you whether optimising arithmetic is worth any effort at all. You will finish able to predict which loop is faster and say why.

Computer Science

intermediate

Information Theory and Compression

Shannon proved in 1948 that information has a hard, measurable limit, and nearly every file, stream and disk you touch is built on that result. This path works through it. You will learn what entropy really measures and why cross-entropy is the loss function that trains language models, how Huffman and arithmetic coding approach the compression floor, where lossy formats like JPEG and AAC actually discard information and why that is a deliberate tradeoff, and how error-correcting codes let data survive a noisy channel.

Computer Science

intermediate

How Computer Networks Actually Work

A request leaves your browser and arrives somewhere across the world in tens of milliseconds. This path follows it the whole way down. You will learn how headers nest as a packet is built, why MTU mismatches cause the classic bug where small requests work and large ones hang, how routers choose a path by longest prefix match and how a BGP mistake can take a network off the internet, how TCP turns an unreliable network into an ordered stream and what congestion control is really negotiating, and why HTTP/3 abandoned TCP for QUIC.

Computer Science

intermediate

How Operating Systems Actually Work

Every program runs on top of a kernel making decisions for it: which thread gets the CPU, which pages stay in memory, when a write really reaches disk. This path opens that layer up. You will learn what a process actually is and what a context switch costs, how virtual addresses become physical ones through page tables and the TLB, what happens when code crosses into kernel mode and why that crossing is expensive, and how the page cache and fsync decide whether your data survives a crash. It closes on containers as ordinary kernel features rather than magic.

Programming

beginner

No-Code Automation: Building Workflows That Keep Working

These platforms remove the cost of writing integration code, which was real, and leave the cost of operating an integration, which is larger and arrives later. This cursus covers why automations break once they run unattended, why partial failure is worse than total failure, and the idempotency problem behind most real damage. Then the patterns that survive production: validation, safe retries, rate limits, testing what you cannot test, and credentials. It ends on ownership, shadow automation, and when a flow has outgrown the tool.

Business

beginner

Facilitation: Running Meetings That Decide Something

Most meetings fail before anyone speaks, in decisions about purpose, attendance and preparation. This cursus separates the four things meetings are for and why mixing them fails, then covers the room: why the first speaker anchors everyone, how to redistribute airtime, why easy agreement is a warning, and diagnosing disagreement by type. It ends on longer sessions, designing backwards from an artefact, retrospectives people tell the truth in, and why outcomes evaporate afterwards.

Business

beginner

Critical Thinking When the Machine Does the Drafting

The cues people use to judge writing, fluency, confidence, structure, specificity, worked because producing them was costly. They are now free and uniform, so they carry no information while still feeling like they do. This cursus covers the five mechanisms that defeat judgement, why resolving to be careful is the thing that has been tested and fails, how to check when checking costs more than generating, and what delegating thinking does to the person delegating it.

Science

advanced

Quantum Cryptography: QKD, Its Limits, and What Ships Instead

Quantum cryptography and post-quantum cryptography share a name and almost nothing else: one uses physics and needs hardware, the other is classical maths and ships as a software update. This cursus builds QKD properly, from no-cloning through BB84 to the error threshold and Ekert's Bell-test version. Then the gap between an unconditional proof and a product: the authentication it cannot bootstrap, trusted nodes, attacks on real detectors, and why NSA and NCSC advise against it. It ends on what is actually being deployed.

Business

beginner

Communication for AI and Data Teams

Technical people explain badly for specific, fixable reasons rather than through lack of effort, and you cannot assess your own explanation from inside it. This cursus covers the question under the question, choosing depth by offering rather than guessing, and the words that mean something else to your audience. Then uncertainty: the two kinds of error, numbers as consequences, and showing real mistakes before deployment. It ends on adoption, which is decided by conversations that happen long before launch.

Business

beginner

Cybersecurity for Small Business: What Actually Matters

Small businesses are told to do everything and can afford almost nothing. This cursus starts from what actually happens to organisations of ten people, which is a short list, and identifies the six controls that address nearly all of it in about a weekend. Then ransomware: how it really unfolds, why backups no longer make you immune, what the first day looks like, and how the payment decision is settled months in advance. It ends on data you should delete, devices you do not manage, and the customer questionnaire you cannot answer.

Business

beginner

AI-Era Security Awareness: Deepfakes, Cloning, and Phishing

The security training most people received taught them to spot bad grammar and odd domains. Those signals described attacker constraints that no longer exist, and checking for them now produces false confidence. This cursus covers what actually changed, why recognition is no longer identity, and the one defence that holds regardless of how good generation gets: verifying the request out of band rather than judging the person. It ends on the risk running the other way, from the AI tools you bring in yourself.

Business

beginner

From Spreadsheet to Insight: Analysis Without a Data Background

Analytical errors in business rarely look like errors. They look like answers. This cursus builds the habits that catch them: restating a vague question as something measurable, finding out what your data was actually collected for, and looking at it before summarising it. Then the technical layer, which is small: tidy data, pivot tables, and joins that silently drop or duplicate rows. It ends on the five analytical patterns that answer most business questions, and what you may honestly conclude from each.

Business

beginner

Data Storytelling: Turning Numbers Into a Decision

Most data presentations fail before a chart is drawn, because they are organised around what the analyst found rather than what the audience must decide. This cursus starts from the decision, inverts the delivery order, and puts one message in every exhibit. Then charts: why chart choice follows from the comparison, which encodings people read accurately, and how averages hide the finding. It ends in the room, on socialising findings, handling challenge, delivering unwelcome results, and where persuasion becomes manipulation.

Business

beginner

AI for Nonprofits: Grants, Communications, and Evidence

A grant application is an evidence problem wearing a writing problem's clothes, which is why fluent generated applications get rejected. This cursus separates the repetitive layer, worth compressing, from the local evidence that actually decides funding. Then operations on almost no budget: reporting that earns the next grant, the free tier trap that puts beneficiary data on the weakest terms, and donor work. It ends on evidence: what a small charity can honestly claim, why feedback flatters, and where analysis genuinely helps.

Business

beginner

AI for Executive Assistants: Calendar, Inbox, and Judgement

The role reads as a list of logistical tasks and is mostly judgement about priority, access and relationships. This cursus separates the mechanical layer, which automates cleanly, from the discretionary layer, which is where the value sits. It covers inbox triage as a model of one person, the daily brief, travel and what happens when it breaks, and protecting attention rather than filling time. It ends where the role is most exposed: impersonation fraud, and the verification habits that survive a convincing executive in a hurry.

Business

intermediate

AI for Journalists and Writers: Research, Voice, and Verification

Journalism looks like a writing job and is mostly a reporting job, which is exactly what a model trained on written material cannot do. This cursus separates the two, sets the bright line around fabrication, and shows why safe uses are the ones where you supply the material. Then voice: why generated prose has a recognisable register, what voice is actually made of, and using the tool as an editor rather than a ghostwriter. It closes on verification, the liar's dividend, and why detection tools are the weakest link.

Business

intermediate

AI for Supply Chain: Forecasting, Documents, and Exceptions

The biggest wins in this field are not where everyone looks. This cursus starts with forecasting and explains why better models rarely help: most error is process or structure, the bullwhip effect is not a forecasting failure, and forecast value added usually shows human adjustment making things worse. Then trade documents, where extraction genuinely transforms the work, and where tariff classification, origin and sanctions screening carry real legal exposure. It ends on exception handling, which is where planners actually spend their day.

Business

intermediate

AI for Architects and Engineers: Specs, Documents, and the Seal

Design is a minority of the hours in a practice; documentation and contract administration are most of them, and that is where these tools land. This cursus separates the work, then explains the professional seal as a licensed person certifying their own judgement, which no tool can hold. It covers why building codes produce the worst kind of confident wrong answer, how to draft specifications without inventing standards, submittal and RFI workflows, and the care, insurance and coordination questions a practice has to answer.

Business

beginner

AI for Small Business Owners: Running It All Yourself

A one-person business is not a small company, it is one person switching between every function with nobody to check the work. That changes which tools pay off. This cursus finds the real constraints, attention and the missing reviewer, then builds the stack: handling enquiries without interruption, quoting safely, keeping books current, and marketing that still sounds like you. It closes on the rules that apply at any size, honest claims, real reviews, telling customers when it is a bot, and customer data.

Business

intermediate

AI for Tax Professionals: Research, Memos, and Authority

Tax runs on an enumerated hierarchy of authority, and the regulation defining it already excludes treatises and the opinions of tax professionals. A generated answer falls on the same side of that line, which settles how these tools may be used: to find authority and to write, never to be it. This cursus covers the four kinds of tax work, retrieval versus recall in research, what a memo is protecting, and the diligence, privilege and penalty rules that keep a named person on the hook.

Business

intermediate

AI for Financial Advisors: Prep, Documentation, and the Regulated Line

Advice is the one part of this job a regulator has assigned to a named person, and no tool can hold a fiduciary duty. This cursus separates the five things in a practice, shows why administration is the real target and recommendation is off the table, then walks the workflows: meeting prep, capture and documentation, client-ready explanation, and research digestion. It closes on running tools inside a supervised perimeter, the SEC's AI-washing enforcement, and what a client structurally cannot get elsewhere.

Business

intermediate

AI for Real Estate Agents: Listings, Leads, and the Legal Line

Property marketing sits inside consumer protection and anti-discrimination law, which makes generated listing copy riskier here than almost anywhere else. This cursus maps where AI actually helps across listings, leads and comparables, then covers the fair housing rules that reach the wording, the workflows for content, enquiries, valuation and chain tracking, and the heavier regime around tenant screening. It ends on disclosure: what must be labelled, the adoption principle that makes provenance irrelevant to liability, and what a client structurally cannot get from a tool.

Business

intermediate

AI for Consultants: Research, Synthesis, and What You Sell

Consulting bills for a bundle of research, analysis, synthesis and judgement, and AI compresses those at very different rates. This cursus separates them, exposes the synthesis trap where generated analysis reads like insight and delivers convention, and confronts the pricing problem that follows when the deliverable gets cheap. Then the production workflows and the sourcing chain that keeps a deliverable defensible. Then positioning: the disclosure conversation, advising on AI while using it, and what a client structurally cannot do for themselves.

Business

intermediate

AI for Customer Support: Deflection, Assist, and the Handoff

Support automation is sold and measured on deflection, a metric that cannot tell a solved problem from an abandoned customer. This cursus starts by replacing it, covers which contacts automate well, and why grounding is a legal requirement here rather than a quality preference. Then agent assist, which usually pays better at lower risk, including the suggestion-acceptance trap and what happens to new agents learning the job. Then running it: curating a corpus from ticket history, escalation that triggers early, and the volume mix that hardens once the easy contacts leave.

Business

intermediate

AI for Project Managers: Plans, Status, and Judgement

Project management splits cleanly into administration that AI handles well and judgement it cannot touch, and the split determines everything. This cursus covers where the fit is genuine, why estimation is the seductive case that mostly fails, and the status reporting split that keeps reports honest. Then the workflows: plan decomposition as a recall problem, the documentation debt that finally becomes affordable, and the portfolio view a PMO can gain. Then introducing it without losing the credibility the role runs on.

Business

intermediate

AI for Marketers: Content, Targeting, and Honest Measurement

Marketing adopted AI faster than almost any function and has the least reliable evidence about whether it helped. This cursus is the honest version. Where the capability genuinely fits across the funnel, why cheap generation moves the constraint to attention rather than removing it, and where the legal edges sit, including the recruitment advertising most marketing teams do not realise is high-risk. Then the workflows: a content pipeline that keeps claims grounded, creative testing that stays powered, and the research synthesis that is quietly the highest-value use. Then what to measure.

Business

intermediate

AI for HR: Recruitment, People Ops, and the Legal Line

HR is where AI meets employment law most directly, and one of the eight Annex III high-risk areas. This cursus starts with the map: what the tools do, which uses are prohibited outright, and why the Article 6(3) derogation rarely rescues a screening tool. Then the workflows, from job descriptions and onboarding through to the screening spectrum and the label problem that means a hiring model reproduces past decisions rather than predicting performance. Then vendors, measurement on your own applicants, and what the candidate is owed.

Programming

advanced

Deploying Open-Source LLMs Privately

Self-hosting is usually justified on privacy grounds, and the argument is weaker than assumed: it changes who owns the controls, not whether controls are needed. This cursus examines the decision honestly, the reasons that hold up better than privacy, and the middle options the either-or framing hides. Then the serving stack: why generation is memory-bandwidth-bound, how continuous batching and KV cache management decide throughput, and sizing hardware. Then operating it, including the safety layer you inherited and must now rebuild.

AI

advanced

Fine-Tuning versus RAG: A Decision Framework

They are usually presented as alternatives when they change different things: fine-tuning adjusts behaviour, retrieval supplies knowledge. This cursus makes the choice properly. Why fine-tuning is a poor way to add facts, what it is genuinely good at, and the three questions that settle the matter on their own. Then what building each involves, from LoRA and the training-data problem that stalls most projects to the retrieval pipeline. Then the options the framing hides, long context, prompt caching, agentic retrieval, and how to revisit a decision that has expired.

AI

advanced

Vector Databases in Depth

Exact nearest neighbour search is intractable at scale and k-d trees collapse above a couple of dozen dimensions, so every production system trades recall for speed. This cursus covers that trade properly. Why the classical indexes fail and how to measure recall against brute-force ground truth. Then HNSW as a navigable small-world graph, IVF as partition-and-probe, and the quantization schemes that decide your infrastructure bill. Then hybrid search, a tuning method that starts from a stated target, capacity planning, and the operational failures no benchmark shows.

AI

advanced

Bias Detection and Fairness Testing

Fairness has several formal definitions that sound equally reasonable, and Chouldechova and Kleinberg proved you cannot satisfy them all at once. This cursus is the hands-on version. Separating the three meanings of bias, tracing the six points where disparity enters, and why removing a protected attribute hides the problem rather than fixing it. Then the metrics, the impossibility result, and choosing a criterion by asking which error harms the person more. Then running an audit that produces a documented, accepted trade-off rather than a claim to have removed bias.

Business

intermediate

Operationalizing Responsible AI

Almost every organisation has AI principles and almost none can name a product decision that came out differently because of them. This cursus closes that gap. Why a value is not a decision rule, and the four things it needs before it binds: a named population, a chosen measurement, a threshold set in advance, and a consequence. Then the machinery, three gates rather than one launch review, checklists that produce decisions, and who can actually stop a launch. Then what happens after: detecting harms nobody in the organisation experienced, redress, and honest measurement.

Business

intermediate

Redesigning Workflows Around AI

Most office processes are ninety percent waiting, and AI reduces touch time while doing nothing about queues. This cursus is the method that follows: map the real process rather than the documented one, find the constraint that governs throughput, and measure the baseline you will later be judged against. Then the six redesign moves that apply when a step becomes cheap, and why review almost always needs relocating. Then implementation without stopping the operation, the counterweights that catch a hollow win, and when not to redesign at all.

Business

intermediate

Managing AI-Augmented Teams

AI changes tasks rather than jobs, so a role reweights toward its harder parts instead of shrinking, and the work moves to whoever reviews. This cursus is for managers rather than builders: what actually changes and why self-reported productivity is unreliable, how to decide what to delegate using the verification tax, disclosure norms and holding the quality bar, and how to drive adoption that is real rather than reported, including the equity problems inside a team and answering questions about job security honestly.

Programming

intermediate

Building an AI QA Function

Software QA assumes a specification, deterministic behaviour, and a system that changes only when you change it. An AI feature violates all three, and a provider updating a model shifts behaviour with no commit for your pipeline to catch. This cursus covers what replaces the old practice: characterising a distribution rather than asserting correctness, the evaluation set as the function's real asset, a release gate with thresholds set before results are seen, and how to stand the function up in ninety days without it quietly dying.

AI

advanced

Hallucinations: Detection, Grounding, and Abstention

A model trained to predict the next token has nothing in its objective that represents truth, so a fabricated citation is a plausible continuation rather than a malfunction. This cursus covers what follows: the taxonomy that tells you whether a failure is a generation or a corpus problem, why fluency carries no signal and why self-review does not work, grounding and the detection methods that compare output against something external, and abstention, including calibration, the coverage-accuracy trade, and building a system that can say it does not know.

Business

advanced

AI Guardrails for Regulated Industries

A supervisor cannot verify a statistical system directly, so they verify whether your organisation could have caught a problem. This cursus covers the evidence that satisfies that question: three lines of defence, effective challenge, and the model risk tradition, including the 2026 move from SR 11-7 to SR 26-2 and the gap it leaves by excluding generative AI. Then human oversight made real and testable, and audit trails that reconstruct a decision. Then validation redirected from outputs to pipeline, and how to document a position when no framework covers your system.

AI

advanced

LLM Guardrails and Red-Teaming

A language model receives instructions and data through one channel and cannot reliably tell them apart, which is why prompt injection has no equivalent of the parameterised query. This cursus builds the defence that follows from that fact: the threat model, from the OWASP Top 10 through indirect injection and the lethal trifecta; the control layer, with its five rail types, the false-positive budget that kills deployments, and why architectural containment beats filtering; and red-teaming that produces findings rather than reassurance.

Business

intermediate

Working in AI Governance: The Function, the Skills, the Way In

Unlike the GDPR's data protection officer, the AI Act mandates no designated officer, which is why this work is currently done by people whose title says something else. This cursus describes the function rather than the job title: the seven recurring tasks, how they split across legal, risk, privacy and engineering, and where the seams fail. Then the four competencies and how deep each must go, with an honest read on certifications. Then what to actually produce, routes in from each adjacent profession, the first ninety days, and the parts of the work that are genuinely unpleasant.

Business

intermediate

Buying AI: Vendor and Procurement Due Diligence

An AI purchase differs from ordinary software in four ways a demo will not show you: the behaviour is statistical, the performance is conditional on data you have not seen, the purchase changes your regulatory position, and the product does not stay the same. This cursus covers the whole buy: scoping the decision rather than the tool, and settling whether you remain a deployer or become the provider; the diligence pack, why instructions for use are the key document, and designing a pilot that can actually fail; then the contract terms, drift monitoring, incident cooperation and exit.

Business

advanced

High-Risk AI Systems: Classification and Conformity

One determination decides whether an organisation faces a substantial compliance programme or almost none: is this system high-risk? This cursus works through that threshold and what lies beyond it. Both classification routes, the Annex III boundaries that actually get argued, and the Article 6(3) derogation with the profiling limit that closes it. Then Articles 8 to 15 read as engineering requirements. Then the route to market: which conformity procedure applies, why most Annex III systems are self-assessed, CE marking, substantial modification, and what continues after launch.

Business

intermediate

Building an AI Governance Framework

Most AI governance starts by writing a policy, which governs nothing, because a policy sets rules about a population of systems nobody has identified yet. This cursus builds the framework in the order that works: find the AI systems you actually run, including those inside software nobody bought as AI, classify them and assign owners who can stop them; then the policy, decision rights and risk register on top; then the documentation the AI Act requires, from Annex IV through logs, impact assessments and registration, generated as a byproduct rather than reconstructed at audit.

Business

intermediate

The EU AI Act for Non-Lawyers

The AI Act is not a set of rules about AI, it is a set of rules assigned to roles, and the same system produces different duties depending on whether you built it or bought it. This cursus works through it without legal training: what counts as an AI system, the provider and deployer roles and the ordinary acts that switch you between them, the four risk tiers and the timeline as amended by the 2026 Digital Omnibus, and a proportionate path for an organisation without a legal department, including the SME simplifications and when a question genuinely needs a lawyer.

Business

intermediate

AI Literacy Programs: From the EU AI Act to Training That Works

The EU AI Act made AI literacy an obligation, then softened it in 2026 from ensuring a sufficient level to supporting its development. This cursus covers what actually applies now: the Article 3(56) definition, the amended Article 4, who is bound, and the neighbouring duties that stayed hard. Then it turns the Act's own factors into a design method, inventory to tiered curriculum, and closes on delivery, refresh triggers, the records that count as evidence, and what a literacy program cannot fix.

Business

intermediate

The Company Brain: AI Search Over Your Own Knowledge

Every organization forgets what it knows, and pointing a language model at the company drive does not fix it. This cursus builds the real thing: why institutional memory decays and what the 1990s knowledge-management wave already proved, then the architecture that is specific to doing retrieval inside a company (connectors, permission-aware retrieval, entity resolution, staleness), then the write path that decides whether any of it works, with evaluation, a permission regression suite, and the failure modes that end these projects.

AI

advanced

Explainable AI: Making Model Decisions Accountable

A model that predicts well can still be impossible to justify, and "the algorithm decided" is not an answer to a rejected applicant, a clinician, or an auditor. This cursus builds the field from the mechanism up: the taxonomy and the global tools (permutation importance, partial dependence, ICE), then local attribution with LIME and SHAP including the Shapley axioms that make SHAP unique, then Integrated Gradients, Grad-CAM, and counterfactual explanations. It ends with the harder question: explanations can fail silently or be deliberately faked, so how do you check yours?

Computer Science

intermediate

Digital Twins: Virtual Replicas of the Physical World

A digital twin is a virtual replica of a specific physical asset, kept in sync by live data so you can predict, optimize, and experiment safely in software. This cursus builds the concept precisely: what a twin is and how it differs from a plain simulation, what it is made of (physics and data-driven models, the sensor and data layer, and the types from component to process scale), and where it pays off, predictive maintenance, manufacturing, energy, and more, alongside an honest look at the data, drift, cost, and security challenges.

AI

advanced

Energy-Based Models: One Lens for Machine Learning

Energy-based models replace input-to-output functions with a scalar energy that scores how compatible a configuration is, the framework Yann LeCun has advocated for decades. This cursus builds it: the energy landscape and inference as finding the lowest-energy answer, how to train one when the partition function is intractable (contrastive divergence, noise-contrastive estimation, score matching, and regularized methods), and the unifying view in which classification, self-supervised learning, JEPA, and diffusion all become one idea.

AI

advanced

Self-Supervised Learning: How Machines Learn Without Labels

Labels are the bottleneck of deep learning, and self-supervised learning is how models learn from unlabeled data instead, the approach Yann LeCun calls the dark matter of intelligence. This cursus builds it from the ground up: pretext tasks and the shift to joint embeddings, the collapse problem that lurks underneath, contrastive methods that fix it with negatives (SimCLR, MoCo), and the negative-free families that fix it without them (BYOL, SimSiam, VICReg, Barlow Twins, MAE), with the through-line to JEPA and the energy-based view.

Robotics

advanced

Vision-Language-Action: How Robots Learn to Act

The frontier where robotics meets large multimodal models. This cursus builds the modern robot-learning stack from the ground up. First, why robots learn skills from demonstrations instead of hand-written controllers, and the compounding-error problem that makes it hard. Then the two ideas that fixed it: action chunking and diffusion policies, plus the pooled multi-robot datasets behind generalist control. Finally, vision-language-action models, RT-2, OpenVLA, and pi0, that put a web-pretrained brain behind the robot, with an honest look at what they can and cannot yet do.

Science

intermediate

How mRNA Medicines Work

mRNA medicines do not deliver a drug, they deliver the instructions and let your own cells build it. That inversion, and the decades of work behind it, is one of the biggest stories in modern biotechnology. This cursus explains it end to end: the engineered mRNA strand and the Kariko-Weissman modified-nucleoside breakthrough that made it usable, the lipid nanoparticle that smuggles it into cells, and what the platform can treat, from COVID vaccines to personalized cancer vaccines and beyond, with the honest limits that remain.

Business

intermediate

Negotiation Fundamentals

Negotiation is a learnable skill, not a personality trait, and it decides salaries, deals, and partnerships. This cursus builds it from the ground up. First, see past positions to the interests beneath, and learn why creating value beats fighting over a fixed pie. Then measure your real leverage with BATNA, reservation price, and the ZOPA. Finally, move the outcome your way: anchoring and first offers, multiple-offer techniques that create and claim value at once, common tactics and their counters, and how to negotiate when you have no Plan B.

Programming

intermediate

Subversion (SVN): The Centralized Version Control System

Git won, but Subversion never left, and plenty of long-lived, high-value codebases still run on it. Knowing SVN makes you useful where the code actually lives, and it sharpens your sense of what Git chose and why. This short cursus covers SVN on its own terms: the centralized model with its global revision numbers and atomic commits, the everyday update-edit-commit workflow with conflicts and locking, and branches, tags, and merging built from cheap directory copies, plus how to bridge to Git with git svn.

Programming

intermediate

Healthcare Interoperability: HL7, FHIR, and Integration Engines

Clinical systems do not speak the same language by default, and someone has to make them. Healthcare interoperability is a durable, in-demand engineering niche with a low barrier to practice. This cursus builds it from the ground up: the interoperability problem and the HL7 v2 message model that still carries most hospital traffic, then FHIR's modern resource and REST API model, and finally the integration engine, Mirth Connect, that routes and transforms clinical data between systems, plus the concrete skills to break in.

Business

intermediate

How to Become a Product Marketing Manager

The best product does not win, the best-understood one does. Product marketing is the discipline of bringing a product to market so buyers get it, want it, and choose it, and one of the most accessible strategic roles in tech. This cursus covers the role: how a PMM differs from a product manager and why they are the connective tissue between product, sales, and marketing. Then the strategic core: positioning with April Dunford's framework, and messaging that leads with value. Finally go-to-market: tiered launches, sales enablement, competitive intelligence, and how to break in.

Business

intermediate

How to Become a Customer Success Manager

In a subscription business the sale is the beginning, and keeping customers matters more than winning them. Customer success is the discipline that delivers retention, and one of the most accessible career switches in tech. This cursus covers the economics: why net revenue retention runs SaaS and the leaky-bucket math. Then the proactive craft: onboarding to fast value, driving adoption, and health scores that predict churn early. Finally the payoff: renewals as an outcome not an event, expansion done as service, saving at-risk accounts, and how to break in.

Business

intermediate

How to Become a Sales Engineer

The sales engineer is the technical half of a sales team, one of the best-paid tech roles you can enter from a technical or a sales background. This cursus builds the craft. First the role: the account-executive partnership, why the SE owns technical trust rather than the close, and why honesty is the whole job. Then the core skill: discovery that finds the real problem, MEDDIC-style qualification, and a demo that proves the buyer's pain is solved rather than touring features. Finally the back half: scoping a proof of concept, surviving RFPs and security review, and how to break in.

Business

beginner

HubSpot Essentials: Inbound and the All-in-One CRM

HubSpot is the fastest-growing major CRM, and it grew from a philosophy: attract customers with useful content instead of chasing them. This cursus teaches HubSpot through that lens. Start with inbound, the flywheel that replaces the funnel, the free-CRM freemium model, and the Hubs, plus how it contrasts with Salesforce. Then the contact-centric data model, lifecycle stages, the marketing tools, and lead scoring. Finally workflows versus sequences, attribution reporting, choosing HubSpot or Salesforce, and the marketing-ops and RevOps careers opened by free HubSpot certifications.

Business

intermediate

Salesforce Essentials: The Platform and the Admin Career

Salesforce is the largest CRM, but it is really a metadata-driven platform you configure rather than code, and knowing how is a credentialed, no-degree career. This cursus teaches the durable architecture. Start with the platform: multi-tenant cloud, metadata, the org, and the clouds. Then the data model: standard objects like Account and Opportunity, custom objects, and lookup versus master-detail relationships, with lead conversion. Finally automation with Flow, the layered security model, why governor limits exist, and the path to Salesforce Certified Administrator.

Business

beginner

CRM Fundamentals: How Customer Data Runs a Business

A CRM is not sales software you happen to use, it is the shared memory of the business, the single structured record of every customer relationship. This cursus teaches the discipline underneath every CRM, so any specific tool becomes readable. Start with the data model: companies, people, leads, deals, and activities, linked into one 360-degree view. Then movement: sales pipelines, the marketing-to-sales lifecycle, the three types of CRM, and automation. Finally the hard part: why most CRM projects fail on adoption and data quality rather than software, and how CRM skill becomes a career.

Business

beginner

Medical Billing and Coding: A Career Guide

In US healthcare, care does not become revenue until it is translated into codes and paid by an insurer, and that gap is a whole profession. This is a career switcher's guide to it. Start with the revenue cycle and the two jobs: coding turns care into codes, billing turns codes into cash. Then the code sets, ICD-10 for diagnoses, CPT for procedures, HCPCS for supplies, and the medical-necessity link that decides payment. Finally the claim lifecycle, denial management where billers earn their value, the compliance line between accuracy and fraud, and how to get certified and hired.

Business

intermediate

How to Become a Solution Architect

A solution architect stands between a business problem and a technical solution and is accountable for whether the solution fits. This cursus builds the discipline, which is judgment, not coding. Start with the role and how it differs from enterprise and technical architects. Then requirements: the functional, the non-functional quality attributes that quietly decide the architecture, and the hard constraints. Finally the craft: analyzing trade-offs, build versus buy on total cost of ownership, recording decisions with ADRs, communicating with the C4 model, and how a switcher breaks in.

Business

intermediate

Shopify Automation: Flow, Functions, and APIs

Most store work is a rule executed by hand: tag this order, discount that cart, sync the warehouse. Shopify gives you three layered ways to automate it, and the real skill is picking the shallowest one that works. This cursus covers Flow, the no-code trigger-condition-action builder that handles most of it; Functions, WebAssembly running inside checkout to change discounts, shipping, and validation as they happen; and the Admin GraphQL API with webhooks and bulk operations, where you gain full power and inherit software you own forever.

Business

intermediate

Stablecoins for Business: Payments, Treasury, and Risk

A stablecoin is not really a crypto story. It is a claim on an institution that happens to settle like software, and every interesting question about it is a credit and liquidity question. This cursus starts with the mechanism: the mint-and-redeem arbitrage that holds the peg, and what the Terra collapse and the USDC depeg each proved. Then the business case: why correspondent banking is slow, what changes when the transfer is the settlement, and how to read the volume numbers honestly. Finally the GENIUS Act, the yield ban, and the risks the rules leave behind.

Business

intermediate

Agentic Commerce: How AI Agents Buy Things

Letting software spend your money is not a shopping problem, it is a security problem. This cursus builds it properly. First, how a card payment actually works: the five parties, authorization versus settlement, interchange, and the tokenization idea everything rests on. Then the mechanism: scoped single-use payment tokens, signed intent and cart mandates, agent identity, and guardrails that bound what an agent may buy. Finally the unsettled parts: liability for an authorized mistake, merchant incentives, prompt injection at checkout, and why the forecasts disagree tenfold.

Business

intermediate

AI for Insurance: Underwriting, Claims, and Fraud

Insurance is a prediction business: you take money now for a promise about an uncertain future. That makes it an unusually natural fit for machine learning, and an unusually regulated one. This cursus starts with how insurance works, risk pooling, the premium equation, the combined ratio. Then where AI does the work: rating models, telematics that measure behavior instead of proxying it, claims pipelines that read photos and settle simple losses fast, fraud models that refer to investigators. It ends with the rules: proxy discrimination, the NAIC bulletin, NYDFS, and the EU AI Act.

AI

advanced

JEPA: Learning by Predicting Representations

Most self-supervised models either reconstruct pixels, wasting capacity on detail nobody can predict, or contrast augmented views, baking in hand-crafted bias. JEPA takes a third path: predict the representation of what is hidden, so the model can discard the unpredictable. This cursus builds it from the ground up: why predicting representations beats predicting pixels, then the machine itself, encoders, predictors, and the collapse problem that asymmetry and stop-gradients defeat, and finally I-JEPA and V-JEPA 2, where the idea becomes a world model that plans a robot's actions.

Business

intermediate

How to Become a UX Designer: Design People Love

UX design is a popular creative career switch, and it is far more than making things pretty. This cursus builds the real discipline. Start with what UX is: user-centered design, UX versus UI, and the double-diamond process. Then research: understanding users and defining the right problem. Then the craft: information architecture, wireframes, prototypes, and UI fundamentals from structure to style. Finally evaluation: usability testing, Nielsen's heuristics, accessibility with WCAG, and how to build a portfolio and break in.

Business

intermediate

How to Become a Project Manager: Plan, Execute, Deliver

Project management is a high-demand career you can enter from almost any background, built on organization and communication more than technical skill. This cursus builds the real discipline. Start with the role: owning an outcome and balancing scope, time, and cost in the iron triangle. Then planning: work breakdown structures, schedules, the critical path, and RACI. Then execution: tracking, risk management, change control, and stakeholders. Finally methodologies: waterfall, agile, and Scrum, how to choose, and how to earn credentials and break in.

Business

intermediate

How to Become a Product Manager: The Core Skills

Product management is one of the most in-demand career switches in tech, high-paying, skills-based, and no coding required, yet widely misunderstood. This cursus builds the real skills, not the myths. Start with what a PM actually does: leading a product trio through influence, measured on outcomes not features. Then the craft: discovery to find what is worth building, prioritization frameworks like RICE to decide what to build, and metrics, MVPs, and the build-measure-learn loop to ship and improve. Each lesson ends with how a career switcher can practice and break in.

Business

intermediate

HR for Entrepreneurs: Build and Lead Your First Team

The moment you make your first hire, you are the HR department, and people decisions make or break a small company. This founder-focused cursus turns HR into a practical discipline. First, hiring: when to hire, writing a scorecard, and structured interviews that actually predict performance. Then onboarding, culture, one-on-ones, and delegation to turn hires into an engaged team. Finally the higher-risk parts founders avoid: fair pay, cash versus equity, worker classification, and letting people go humanely and legally.

Business

intermediate

Why Buyers Say Yes: Behavioral Sales Techniques

Buyers decide with a fast, emotional, bias-driven mind and justify with logic. This cursus turns that science into a sales method. Start with the buyer's brain: System 1 and 2, loss aversion, anchoring, status-quo bias, and Cialdini's principles of influence. Then the conversation craft: SPIN questions, the talk-to-listen ratio from winning calls, and framing value with anchoring. Finally the close: objections as signals, small yeses, risk reduction, and honest urgency, with one throughline throughout, ethical influence beats manipulation every time.

Business

intermediate

Cold Outreach That Works: LinkedIn and Email Automation

Modern outbound is a machine: targeting in, meetings out. This cursus builds it end to end. Start with the front half, an ideal customer profile, a clean list, and data enrichment with tools like Clay and Apollo. Then the email engine: separate domains, SPF, DKIM and DMARC, warmup, sequences, and the Google and Yahoo rules that decide the inbox. Finally LinkedIn automation, safe limits, multichannel sequencing, and the CAN-SPAM and GDPR compliance line, with one throughline: relevance beats volume.

Business

intermediate

AI for Sales: Tools to Close More Deals

Salespeople spend far less time actually selling than most people think, and AI targets exactly the work that gets in the way. This cursus shows how AI helps sales teams from leads to close: scoring and prioritizing leads, personalizing outreach at scale, automating CRM admin to win back selling time, and turning calls into coaching with conversation intelligence, then how to keep it human: why authentic outreach beats spam, what the human close AI cannot replace, and how honesty and trust close more deals.

Business

intermediate

AI for Business Development: Prospecting to Partnerships

Business development runs on research, relationships, and reach, and AI supercharges two of the three while the relationships stay human. This cursus shows how to use AI for deep account and market research, to find and prioritize best-fit prospects and partners, and to personalize outreach genuinely at scale, then how to keep it authentic: why real personalization beats mass spam, what relationship-building and judgment AI cannot replace, and how verification and compliance protect the trust deals depend on.

Business

intermediate

AI in Banking: How Finance Uses Machine Learning

Banking was one of the earliest and heaviest adopters of AI, and for good reason: it is an industry of data and decisions at massive scale. This cursus explains how banks really use AI, fraud detection, credit scoring, anti-money-laundering, and customer service, the mechanics and trade-offs of each workflow, and the guardrails unique to finance, fairness in lending, explainability, model risk management, and accountability, that make powerful, large-scale decisions about people acceptable.

AI

beginner

AI for Students: Study Smarter Without Cheating

AI can be the best study partner you have ever had, or a shortcut that quietly stops you from learning. This cursus shows you the difference. Learn the mindset that separates using AI to learn from using it to outsource thinking, the concrete study techniques that turn AI into a personal tutor, explaining, quizzing, and feedback, and how to use AI honestly so that the honest path and the path that actually makes you smarter turn out to be the same one.

Business

intermediate

AI for Accountants: Automating the Numbers

A practical guide to using AI across accounting while protecting the trust that makes financial information useful. Learn the categories of accounting AI tools and how AI moves audit from sampling toward full-population testing, the core workflows of bookkeeping, reconciliation, anomaly detection, and analysis, and the responsibility practices, verification, audit trails, professional standards, and confidentiality, that keep the accountant accountable for the numbers.

Science

intermediate

AI for Doctors: Clinical Tools and Safe Use

A safety-first guide to using AI in clinical practice, where the stakes are human lives. Learn the categories of clinical AI tools and the difference between regulated diagnostic AI and general assistants, the workflows where AI helps most, ambient documentation, decision support, imaging, and patient communication, and the patient-safety framework, human-in-the-loop oversight, privacy, bias, and accountability, that keeps AI-assisted medicine safe.

Science

intermediate

AI for Scientists: Tools to Accelerate Research

A practical guide to using AI across the research cycle without compromising scientific rigor. Learn the categories of AI tools and the difference between general assistants and specialized scientific models like AlphaFold, the core workflows of literature review, data analysis, coding, and writing, and the integrity practices, disclosure, reproducibility, and avoiding fabrication, that keep AI-accelerated science trustworthy. Objective, evergreen, and built around verification.

AI

intermediate

AI for Teachers: Save Time and Teach AI Literacy

A practical guide for educators to reclaim time with AI without losing what makes teaching human. Learn the categories of teaching AI tools and their caveats, how to generate lesson plans, materials, differentiation, and feedback with the right prompts and review, and how to teach in a world where students have AI too: why detectors fail, how to design meaningful assessment, and how to teach AI literacy while protecting privacy and equity.

Law & Compliance

intermediate

AI for Lawyers: Tools, Workflows, and Ethics

A practical guide to using AI in legal practice without the career-ending mistakes. Learn the landscape of legal AI tools and the risks unique to law (hallucinated citations, confidentiality), the core workflows where AI saves the most time (research, drafting, contract and document review), and how professional duties, competence, confidentiality, candor, and reasonable fees, govern responsible use. Objective, evergreen, and built around keeping the lawyer in charge.

AI

intermediate

Voice AI Agents: How They Actually Work

Voice AI agents you can call and talk to like a person are quietly reshaping customer service and phone support, and they are more clever engineering than magic. This cursus explains how they really work: the streaming speech-to-text, LLM, and text-to-speech pipeline and why latency is everything, the turn-taking and interruption handling that makes a conversation feel human, and the architecture, tools, failure modes, and evaluation behind a production voice agent. Clear, current, and mechanism-first.

Business

intermediate

Data Governance: How Organizations Make Data Trustworthy

Data governance is dismissed as bureaucracy and misunderstood as an IT chore, yet it is what separates organizations that can trust their data from those drowning in conflicting numbers. This cursus explains it clearly and practically: what governance actually is and why most programs fail, who owns data through roles and operating models, the machinery of quality, metadata, lineage, and master data, and the control layer of classification, access, and policy that keeps data safe while still usable.

Science

intermediate

The Science of Longevity: How to Actually Live Longer

Longevity is one of the most hyped topics in health and one of the most misunderstood. This cursus cuts through the noise with the actual science: why we age (the twelve hallmarks of aging), which interventions truly extend healthy years versus which just sell, what the research really shows for longevity drugs like metformin and rapamycin, and how biological age is measured and whether it can be reversed. Evidence-first, mechanism-led, and honest about what we do not yet know.

Computer Science

advanced

How hackers get in (and how to stop them)

A practical, example-driven tour of security from basics to advanced. Start by thinking like an attacker and following a real breach through its five stages, then dig into the human layer of phishing and passwords, then the technical layer where web apps get hacked with real code for SQL injection and XSS, and finally the defender's playbook of least privilege, zero trust, detection, and response. Every attack is paired with its concrete defense.

Business

intermediate

How real estate actually makes money

Real estate is not buy-low-sell-high, it is a leveraged, income-producing, cyclical business, and this cursus shows how it really works. Start with the four channels that pay a property owner, then the leverage that multiplies them, then how income property is priced through NOI and cap rates, and finally the vehicles, risk ladder, market cycle, and the exact way over-leveraged deals collapse. Mechanisms over hype, with worked numbers throughout.

Business

intermediate

Who really pays for a tariff?

Tariffs are one of the most talked-about and least understood tools in economics. This cursus builds the whole picture from the mechanism up: who actually pays a tariff and how the cost splits, why governments impose them despite the cost, how a single tariff can spiral into a trade war, and the global rulebook that keeps trade wars rare. Objective, evergreen, grounded in named research, no slogans.

AI

intermediate

The trillion-dollar AI buildout

AI stopped being only a software story and became one of the largest construction efforts in history: warehouses of specialized chips, new power plants, and hundreds of billions in yearly spending. This cursus explains it from the ground up, why compute became the bottleneck, what an AI data center really is, why electricity is now the binding constraint, and how to judge whether the whole thing is a rational bet or a bubble. Mechanisms, not predictions.

Business

intermediate

How to know what actually works

You changed something and the numbers moved, but did your change cause it? Answering honestly is harder than it looks, and getting it wrong wastes fortunes on things that never worked. Learn why before-and-after comparisons fool you, how a randomized experiment reconstructs the missing counterfactual, the statistical traps that make even a clean test lie, and why experiments quietly break on the social and marketplace platforms where they matter most.

Business

intermediate

Why some platforms win everything

Why do a handful of platforms dominate the digital world while other, similar markets stay competitive? The answer is one force: the network effect, a product that gets better the more people use it. Learn where that power comes from, why the brutal chicken-and-egg cold start decides most winners before the product even matters, and, crucially, why network effects are a tendency and not a destiny, so plenty of networked markets never tip to a single winner at all.

Business

beginner

How creators actually make money

A million followers can be worth a fortune or almost nothing, and this path explains why. Learn the seven ways creators get paid and who bears the risk in each, why creator income follows a brutal power law that headline statistics hide, and the one move every durable creator makes: use rented platform reach to build an audience you actually own. Finish able to plan income that survives an algorithm change.

Business

intermediate

How Google actually ranks the web

Behind the search box is a machine that crawls billions of pages, files them for instant lookup, and orders them the moment you ask. Learn how pages get discovered and indexed (and why most never do), the four questions ranking really answers, why every clever ranking trick eventually stops working, and how the shift to AI-written answers changes the payoff from a click to a citation. Finish able to see search as a system you work with, not a list of tricks to chase.

Business

intermediate

How the internet makes its money

Almost everything you use online is paid for by advertising, and almost none of it works the way people assume. Learn the auction that prices your attention billions of times a day, why the highest bid often loses, the supply chain that carries an ad to your screen in a tenth of a second and eats nearly half the money on the way, and why measuring whether any of it worked is genuinely hard. Finish able to read the ad-funded internet as a system of auctions, incentives, and honest uncertainty.

Business

intermediate

How Chinese social media actually works

Same technology, a completely different shape. One app handles messaging, payments, taxis and government forms. More than half of all internet users buy things through live broadcasts. A scripted format nobody in the West has reached 662 million viewers. This path maps the platforms 1.1 billion people actually use, explains why Douyin is not TikTok and Xiaohongshu is not Instagram, and traces every difference back to a few starting conditions. Finish able to read the market on its own terms instead of through analogies that quietly mislead.

AI

beginner

How AI is actually used in social media

AI does three unrelated jobs on a social platform, and mixing them up causes most of the confusion. Learn the map first: what decides your feed, what generates the content, and what takes it down. Then get an honest account of where generative tools genuinely help and where they invent facts with total confidence, and why nobody, including the detectors sold for the job, can reliably tell you whether something was made by AI. No hype, no tactics, just what the machines do and how they fail.

AI

intermediate

How social media algorithms decide what you see

The same machine runs behind YouTube, TikTok, Instagram and Pinterest, and once you see it the feed stops being mysterious. Learn the two-stage funnel that picks ten items out of a hundred million in a tenth of a second, why optimizing for clicks produces clickbait as a correct answer, and how content embeddings let a post from a zero-follower account reach millions. Finish able to explain any feed's behavior from its objective, and to tell real mechanisms from the folklore creators repeat.

Programming

intermediate

How Unity works: the engine under your game

Stop fighting the engine and start using it. Learn why Unity is built on composition instead of class hierarchies, exactly when your code runs across Awake, Update, and the physics loop, how prefabs and serialization decide what survives to disk, and why physics runs on its own 50Hz clock. Finish able to explain the bugs that stump most Unity developers: the field that keeps resetting, the object that tunnels through walls, and the script that mysteriously never runs.

Programming

advanced

How Python really works: CPython internals

Go under the hood of the interpreter that runs most Python. Start with the object and data model, where every value is a heap object and behavior lives in dunder methods. See how source becomes bytecode and runs on a stack machine with an adaptive interpreter. Learn how reference counting and the cyclic collector reclaim memory. Finish with the GIL and the free-threading build that makes it optional. Come out able to reason about performance, memory, and concurrency from mechanism, not folklore.

History

intermediate

Why the global semiconductor supply chain matters

Why the world's most important industry runs through a handful of firms and places, and what that means. Learn the foundry model and the wafer economics that drive concentration, the lithography monopoly that took thirty years to build, how export controls turn chokepoints into policy instruments, and what supply-chain resilience actually costs. Finish able to analyze any concentrated supply chain with the same structural toolkit.

AI

advanced

Generative AI: diffusion and flow models

How modern image, video, and audio generators actually work, from first principles to the frontier. Learn the denoising mechanism behind diffusion models, the guidance and sampler tricks that turn them into products, the flow-matching reframing that powers state-of-the-art generators, and how diffusion is being rebuilt for text. Finish able to read any generative-model release mechanically: corruption, path, target, and where the inference compute goes.

Law & Compliance

advanced

AI compliance in Europe and Switzerland

The regulatory regimes an AI or fintech operator meets across the EU and Switzerland, in three lessons. Start with the data-protection foundation (GDPR and the revised Swiss FADP), move to the AI Act's risk tiers and the NIS2 security baseline, then finish with financial-sector rules: DORA operational resilience and Swiss banking secrecy. You will learn what each regime requires, whom it binds, and how a compliance program is structured.

Programming

advanced

Reverse engineering fundamentals

How to read a compiled binary back into something a human can reason about. The file format and loader, disassembly and decompilation of x86-64, and dynamic analysis with debuggers and instrumentation. Three lessons of mechanism — what the toolchain on each side actually does, and what no amount of effort can recover.

Business

intermediate

Consumer behavior fundamentals

The mechanisms behind how buyers decide, what drives demand, and what happens after the sale. Decision architecture (System 1/2, anchoring, prospect theory, defaults), motivation and identity (SDT, JTBD, hedonic vs utilitarian, signaling), and the journey beyond purchase (consideration sets, cognitive dissonance, satisfaction, loyalty mechanics). Each lens presented with its replication status, not as a marketing recipe.

Programming

advanced

Advanced Python for backend

The advanced syntax and runtime patterns that production Python backends rely on. Async and asyncio fundamentals, the type system as both static contract and runtime spec, FastAPI's dependency-injection model, and SQLAlchemy 2.0's async ORM — four lessons of mechanism over framework hagiography.

Business

intermediate

Startup financing and cap tables

The math and mechanics of venture-backed equity financing — ownership and dilution, priced rounds and anti-dilution, SAFEs and convertible notes, term-sheet structure, employee equity vehicles across jurisdictions, and the exit waterfalls that determine the per-share outcome. Six lessons of mechanics that apply across every cycle.

Science

intermediate

How energy works

From thermodynamics through grid engineering — the physics, the units, and the engineering trade-offs of every major energy source. Six lessons cover energy and power units, combustion and thermal cycles, nuclear fission, nuclear fusion, solar and wind and batteries, and the grid that ties them together. Mechanism-first, evergreen, no predictions.

Science

intermediate

Genome editing and metabolic medicine

How DNA encodes proteins, how CRISPR/Cas9 cuts and repairs DNA, how base and prime editors achieve precision without breaks, what GLP-1 agonists do across multiple tissues, how clinical trial evidence is built, and how to read the resulting medical evidence. Six lessons, mechanism-first, evidence-aware.

Business

intermediate

Macroeconomics fundamentals

Money, inflation, central banks, and the business cycle — the structural concepts that appear in every economy, in every era. Six lessons, mechanism-first, without policy advocacy or predictions about specific outcomes.

Science

advanced

Quantum computing fundamentals

Understand quantum computing from the physics up: what qubits, superposition, and entanglement really are, how the four leading hardware platforms build them, how error correction turns noisy qubits into reliable logical ones, and which algorithms deliver genuine speedups. Finish able to read any quantum-computing claim critically, from qubit-count headlines to post-quantum cryptography.

History

advanced

The global semiconductor supply chain

Why chip manufacturing concentrated in a handful of firms and regions, how the lithography chokepoint emerged from compounding R&D, what export-control instruments actually do as a matter of law, what catchup historically required, and the structural risks that follow from the resulting concentration. Six lessons, mechanism-first, with no predictions.

Science

advanced

Semiconductors: from band theory to modern chips

A six-lesson path from the physics of silicon to the global chip industry. Start with bands, doping, and the PN junction; build up through diodes and transistors to CMOS gates; then walk the wafer through a fab, decode '5 nm' marketing, and trace how Dennard scaling died and chiplets carry Moore's law forward. By the end you can read a chip datasheet, follow a TSMC roadmap, and explain why every modern SoC is half-dark.

AI

advanced

Loop engineering for LLM agents

Build agent loops that finish, recover from errors, stay on budget, and produce checkable work. Start with the smallest ReAct loop; layer on state management, error taxonomy, and budgets; finish with adversarial verification panels, sub-agent orchestration, and the loop-shaped anti-patterns that ship to prod more than they should.

AI

intermediate

LLM, agent, and RAG evaluation & monitoring

A compact track on how to know your LLM-powered system is actually working: LLM benchmarks vs. real evals, agent trajectory evaluation, RAG evaluation in production, and the OpenTelemetry GenAI conventions that tie traces across LangSmith, Phoenix, and Datadog LLM.

AI

advanced

Reinforcement Learning today

A short, modern tour of where RL is actually working in 2026: the post-RLHF landscape, DPO and its variants, RL with verifiable rewards (GRPO, DeepSeek-R1 style), and how reasoning models use RL on chains of thought.

AI

intermediate

How LLMs work: from scratch

Ten lessons that build up a modern LLM end to end — neural nets and backprop, attention and transformers, tokenization, pretraining, modern architectures and MoE, scaling laws, post-training (SFT/RLHF/DPO), and inference internals like the KV cache.

AI

advanced

Harnesses, MCP, and advanced agent techniques

How modern coding agents are actually built: the Model Context Protocol, MCP server authoring in Python and TypeScript, agent harness design, subagent orchestration, tool-use patterns, and context engineering for long-running agents.

AI

advanced

Advanced RAG: graphs, hybrid retrieval, and evaluation

Nine lessons that take Retrieval-Augmented Generation past the cosine-search baseline. Chunking, hybrid retrieval with rerankers, query rewriting, GraphRAG and HippoRAG/RAPTOR, agentic multi-hop patterns, and how to actually evaluate the whole thing with RAGAS.

Business

intermediate

How the game industry works

Read the $180B+ global games market like an analyst: map the platform segments, understand how the developer-to-player value chain skims revenue, compare distribution channels across Steam, app stores, and mini-games, decode mobile F2P unit economics (CPI, LTV, ROAS), navigate China's ISBN system and Tencent/NetEase gatekeeping, and assess cloud gaming's economics through the lens of Stadia's 2023 shutdown.

Programming

intermediate

Scalable System Design

Design systems that handle millions of users without falling over. You will size and scale app tiers with load balancers and autoscaling, apply caching strategies that cut DB load by 95%, partition databases with sharding and replication, and wire services together with message queues and resilience patterns — leaving you ready to lead a real system design review.

Robotics

beginner

Robotics Foundations

By the end of this path you will be able to describe a robot's three-pillar anatomy, select appropriate sensors for a given task, choose and size the right motor type, write a basic closed-loop controller on a microcontroller, and explain why loop rate and latency matter in real systems.

Robotics

advanced

Robot Perception and State Estimation

By the end of this cursus you will be able to model a pinhole camera, calibrate it with OpenCV, recover stereo depth, downsample and register LiDAR point clouds with ICP, implement a Kalman filter predict-update cycle from scratch, and explain how ORB-SLAM3 and Cartographer solve the full SLAM problem including loop closure and pose-graph optimisation.

Robotics

intermediate

Robot Kinematics

Build a complete kinematic toolbox for serial robot arms. You will attach coordinate frames to every link using homogeneous transforms, compute end-effector pose from joint angles with DH-parameter-based forward kinematics, invert that map analytically and numerically to find joint angles from a desired pose, and differentiate FK to get the Jacobian for velocity control and singularity analysis.

Robotics

intermediate

Robot Control Systems

Build a complete understanding of robot control from first principles. By the end of this path you will be able to design and implement feedback loops, tune PID controllers for real actuators, model multi-joint systems in state space, apply pole placement and LQR, and generate smooth trajectories that a robot arm or mobile robot can track with minimal error.

AI

advanced

Reinforcement Learning Foundations

Go from zero to deep RL in four lessons. You will formalize sequential decision-making as a Markov Decision Process, solve small MDPs exactly with dynamic programming, implement Q-learning and SARSA from scratch, and understand DQN, policy gradients, actor-critic, and PPO well enough to use them in real projects.

Math

intermediate

Probability and Statistics for Machine Learning

Build the mathematical foundation every ML practitioner needs: go from sample spaces and distributions to Bayesian inference and hypothesis testing. By the end you will be able to choose the right distribution for any modelling problem, derive maximum likelihood estimators, reason about uncertainty the Bayesian way, and correctly interpret p-values and confidence intervals.

Robotics

advanced

Motion Planning and Navigation

Go from first principles to a working ROS navigation stack. You will model any robot as a point in configuration space, implement and compare Dijkstra, A*, PRM, RRT, and RRT*, and wire together a global planner, local planner, and AMCL localizer for a real mobile robot.

Math

intermediate

Linear Algebra for Engineers

Master the mathematical backbone of machine learning, signal processing, and scientific computing. By the end you will decompose any matrix into its fundamental subspaces, compute eigenvalues and eigenvectors, apply the SVD for low-rank approximation and compression, and solve least-squares problems — all with geometric intuition and NumPy.

Programming

advanced

How Compilers Work

Follow source code on its full journey from raw characters to machine instructions. You will build intuition for each compiler phase — scanning, parsing, semantic analysis, and code generation — and understand why each exists, what can go wrong inside it, and how the phases connect. By the end you will be able to read compiler error messages with precision, write a toy expression evaluator, and reason about what your compiler is doing when you flip on -O2.

Programming

advanced

Distributed Systems Fundamentals

After finishing this cursus you will be able to design, evaluate, and reason about distributed systems with engineering precision: model failures and time correctly, choose the right consistency level for a workload, explain why consensus is hard and how Raft solves it safely, and architect replication and partitioning strategies that scale without creating hot spots or correctness bugs.

AI

intermediate

Deep Learning Foundations

Build and train neural networks from scratch. By the end you will implement forward and backward passes in NumPy, tune optimizers and regularizers to close the train-val gap, design convolutional architectures for image tasks, and read transformer papers fluently — understanding self-attention, multi-head attention, and positional encodings from first principles.

Programming

advanced

Database Internals

Go beneath the SQL surface and understand how databases actually work. After this track you will be able to explain how data is laid out on disk, why B-trees dominate relational indexes, when to reach for an LSM-tree instead, and how MVCC lets Postgres serve thousands of concurrent readers and writers without blocking. You will read query plans, tune buffer pools and checkpoints, design indexes that avoid heap fetches, and reason precisely about isolation levels and concurrency anomalies.

Programming

advanced

Concurrency and Parallel Programming

Master the full concurrency stack: from race conditions and lost updates, through mutexes and deadlock prevention, to CPU memory models and lock-free atomics, and finally to async event loops and coroutines. After this cursus you can reason about any concurrent system, pick the right synchronization primitive, and debug races and deadlocks methodically.

Programming

advanced

Applied Modern Cryptography

Build the cryptographic judgment to evaluate any system's security posture. You will be able to choose the right primitive for each job (AES-GCM, HMAC, Argon2, ECDH, Ed25519), explain why common constructions fail (ECB, textbook RSA, nonce reuse, bare CTR), read a TLS 1.3 handshake trace, and audit real code for the most dangerous cryptographic misuses.

Business

advanced

AI Transformation in Business

After completing this path, you will be able to assess your organisation's true AI readiness, distinguish genuine P&L impact from pilot theatre, design a measurement framework that produces credible ROI verdicts, evaluate data infrastructure gaps before they sink a deployment, choose the right organisational structure and build-vs-buy posture, and govern AI systems as an audited, continuously monitored practice — not a one-time compliance checkbox. Built on peer-reviewed field studies, the MIT 2025 GenAI Divide, BCG/Harvard, and the EU AI Act.

Business

advanced

AI Agents in Business: The Evidence

Five advanced lessons on what is actually known — from peer-reviewed papers, regulatory filings, and primary disclosures — about AI agents in business. Customer service, coding, legal, scientific R&D, and agentic RPA, each anchored on verifiable sources rather than vendor case studies.

Programming

intermediate

Full-Stack with Node.js, React, and Next.js

An eight-lesson path that builds a full-stack engineer from the runtime up. Start with the Node.js event loop, build a REST API with Express, learn React fundamentals and hooks, master modern data fetching, then move into Next.js App Router, Server Components, Server Actions, and a Prisma + Postgres deployment.

AI

intermediate

AI 3D Mesh Generation: Foundations to Production

A five-lesson tour of how Meshy, Tripo, Rodin, Hunyuan3D, and Trellis actually work in 2026. Starts from the 3D representation zoo, walks through the modern image-and-text-to-3D pipeline, dives into native 3D generative models, covers texturing and PBR, and ends with the production pipeline and platform landscape.

Business

intermediate

SEO and GEO for Crypto and Centralized Exchanges

A seven-lesson path for SEO and content practitioners working in crypto. Starts with a working model of crypto and classical SEO/GEO foundations, then steps up to advanced operator work: programmatic SEO at scale, GEO measurement across AI engines, and E-E-A-T / entity SEO for YMYL content.

AI

intermediate

LLM Models in Practice

Six lessons on choosing and using the right LLM for the job. Get a clear-eyed view of the 2026 model landscape, learn to compare capabilities honestly, understand the open-vs-closed tradeoff, and stop optimizing for benchmarks that don't predict your task.

Programming

intermediate

Parallel Programming with CUDA

A six-lesson path from why GPUs exist to writing your own performant CUDA kernels. Learn the programming model, memory hierarchy, and optimization techniques that turn a 100x speedup from theoretical into practical.

AI

beginner

LLM Basics

A single-lesson taster that introduces the most fundamental concept behind every modern LLM app: the context window. Learn what tokens are, why models forget, and what 'lost in the middle' actually means in practice.

AI

intermediate

Modern AI Beyond Text

Five lessons on AI that sees, hears, and generates. Start with the unifying idea of multimodal models, dive into vision-language models and OpenCLIP, watch video generation make the leap from research to product, then bring it home with AI-aided software development.

Programming

intermediate

API Design & Reliability

Six lessons on shipping an HTTP API that other engineers actually enjoy using. Start with REST principles and status codes, secure it with OAuth 2.0, then make it survive real traffic with rate limiting, idempotency, and load balancing.

AI

intermediate

How Agentic AI systems work

Move beyond single prompts into agents that plan, use tools, and loop. Six lessons covering the agent mindset, the LangGraph framework, the realities of context windows, where humans belong in the loop, the security pitfalls, and how to evaluate non-deterministic systems.

Computer Science

intermediate

System Design Fundamentals

Ten lessons covering the building blocks every backend engineer needs to reason about scale. Move from traffic-shaping and caching through the hard tradeoffs of distributed data, then up to architectural styles that decide how teams ship.

AI

intermediate

How LLM apps work

A practical seven-lesson path from raw model calls to a production-ready RAG application. You'll learn how to ground LLMs in your own data, orchestrate the pieces with LangChain, observe what they actually do, and evaluate the result so you can ship with confidence.

Programming

intermediate

Data Engineering Foundations

An eight-lesson path from SQL fundamentals to a modern data stack. You'll learn how to query and tune relational data, cache hot reads, model with dbt, choose between lakehouse and warehouse architectures, and wire pipelines together with Kafka and Airflow. By the end you can reason about every layer a production data platform actually runs on.