Morrowdock MartyGraphics
Menu

WHAT’S INSIDE

Real courses,
written to teach first.

Courses explain the idea and guide you through it before handing you a fresh problem. Here is everything being written, lesson by lesson.

None of these courses is in the app yet. The private iPad beta has physics practice; these lessons are being written to teach before it. Each status below comes straight from the course files.

Courses
12
Lessons written
14
Draft lessons in review
72
Lessons planned
5

PHYSICS · 1 COURSE

Physics

Being written · not in the app yet

Mechanics: forces and energy, taught

Learn Worked Guided On your own

Lessons

  1. Forces change motion: Newton's laws and free-body diagramsOne object, every force named, then ΣF = ma one axis at a time.Written
  2. Grip, slip and slopes: Friction and inclinesStatic friction is 'as much as needed'. Kinetic friction is μk·N. On a slope, tilt your axes.Written
  3. Ropes that connect: Tension and pulleys (connected objects)One rope, one tension. One rope, one shared acceleration. One FBD per object.Written
  4. Always turning inward: Uniform circular motionConstant speed around a circle still means acceleration, toward the centre, of size v²/r.Written
  5. Force times distance, along the way: Work and the work–energy theoremWork is the part of a force that acts along the motion, times the distance. The net work changes the kinetic energy.Written
  6. Energy changes form, the total doesn't: Kinetic and potential energy, conservationPick two moments, list every kind of energy at each, and set the totals equal. Friction takes its share as heat.Written
  7. How fast the work gets done: PowerPower is energy per second: P = W/t, or P = F v when a force pushes something along at speed v.Written
  8. Pushes over time: Momentum and impulse (preparation for the next unit)Momentum p = m v keeps track of direction. Impulse F Δt changes it, and in a collision the total doesn't change.Written
Before you start
  • Rearrange a one-step equation such as 12 = 3a for a.
  • Use sin, cos and tan of an angle in degrees on a calculator.
  • Treat a positive or negative number as a direction along a line (right +, left −).
  • Use v = v0 + at and v² = v0² + 2aΔx for constant acceleration.

CODE GYM · 1 COURSE

Code Gym

Being written · not in the app yet

SWE interviews: patterns, taught

Learn Guided On your own

Lessons

  1. Remember what you’ve seen: Arrays / hashingSets and dicts turn “compare everything” into one pass.Written
  2. Two fingers on the list: Two pointersMove two indices by a rule that never skips an answer.Written
  3. Slide, don’t restart: Sliding windowKeep the answer for the current run and update it as the edges move.Written
  4. The most recent unfinished thing: StackLast in, first out: brackets, cancellations, undo and next-greater.Written
  5. Halve the haystack: Binary searchFind the first True of a False…True question in about log₂ n checks.Written
  6. Follow the arrows: Linked listRewire nodes without losing the chain: reverse, two speeds, a dummy head and a gap.Written
  7. TreesLater
  8. GraphsLater
  9. Heap / priority queueLater
  10. BacktrackingLater
  11. Dynamic programmingLater

A mock-interview capstone comes after the lessons. It isn’t written yet.

Before you start
  • Write a loop and an if in some language (Lua is fine).
  • Use a Lua table as a map: t[k] = v, t[k] == nil.
  • Read a Python function with def, return, lists and indentation (the Variables lesson covers this).

AI LAB · 10 COURSES

AI Lab

Draft in review · not in the app yet

Building with AI

By the end, you can

  • Call a model API correctly: resend context deliberately, read stop reasons and usage, and retry only what is safe to retry.
  • Get structured output you can trust by validating at the boundary with bounded, visible repair.
  • Build tool loops and agents whose safety comes from code: consent, duplicate protection, budgets, named stop reasons and traces.
  • Read MCP and JSON-RPC traces, judge the trust a server needs, and estimate cost and latency with stated assumptions.

Lessons

  1. Calling a model APIDraft
  2. Structured output you can trustDraft
  3. Tool use: the model asks, your code actsDraft
  4. Keeping a tool loop safeDraft
  5. The Model Context Protocol (MCP)Draft
  6. Agents: loops that plan, act and stopDraft
  7. Cost and latencyDraft
  8. Capstone: an offline tool agent with a budget ledgerCapstone projectDraft
Before you start
  • reading and writing short Python functions with lists and dicts, and running a script on your own computer
  • JSON: objects, arrays, strings, numbers, true/false/null
  • the request/response idea behind a web API (a client sends a request; a server returns a status code and a body)
  • fractions, percentages and multiplying probabilities of independent events
  • recommended first: AI Lab 'How LLMs work' lessons 1-4 (tokens, probabilities, sampling); this course reuses tokens and temperature

Draft in review · not in the app yet

Covariance to PCA

By the end, you can

  • Compute and interpret sample and population covariance of a small table.
  • Derive PCA as maximum projected variance and equivalently minimum reconstruction error.
  • Handle sign ambiguity, nonunique directions, scaling and leakage correctly.
  • Build, test and report a reproducible train-only PCA on new data.

Lessons

  1. Centered data and covarianceDraft
  2. Direction and varianceDraft
  3. Orthogonal projection and reconstruction errorDraft
  4. Eigen directions, degeneracy and signDraft
  5. Scaling, leakage and what explained variance does not tell youDraft
  6. Guided build: a three-sensor PCADraft
  7. Write tests that catch real bugs, then debugDraft
  8. Independent transfer and capstoneCapstone projectDraft
Before you start
  • signed arithmetic and fractions
  • two-coordinate vectors and the dot product
  • reading a data table with one row per observation
  • squares, square roots and solving a quadratic
  • sine and cosine of an angle, including sin 2θ = 2·sinθ·cosθ
  • for lessons 6-8: writing small Python functions and running a script on your own computer (NumPy optional; unittest is taught in lesson 7)

Draft in review · not in the app yet

Deep learning

By the end, you can

  • Track shapes, parameters and scale through deep networks, and explain initialization, normalization and residuals.
  • Compute convolutions, receptive fields, embeddings, positional encodings and masked attention by hand and in code.
  • Count a transformer's parameters, compute and KV-cache memory, and reason about what limits context.
  • Build and test convolution and causal attention from scratch with discriminating tests, without claiming to train an architecture.

Lessons

  1. Shapes, layers and parametersDraft
  2. Training deep networks: initialization, normalization, residualsDraft
  3. Convolution arithmeticDraft
  4. Designing CNNs: channels, pooling and receptive fieldsDraft
  5. Embeddings and positionsDraft
  6. Attention by handDraft
  7. Transformers: blocks, heads, size and costDraft
  8. Capstone: build and test convolution and causal attentionCapstone projectDraft
Before you start
  • matrix multiplication and the shape rule (a, b) @ (b, c) = (a, c)
  • a single neuron, ReLU and the chain rule (AI Lab Neural nets lessons 1-5)
  • softmax and cross-entropy (AI Lab 'How LLMs work' lessons 2-3)
  • mean, variance and standard deviation
  • for notebook steps and the capstone: Python functions, nested lists and loops, and running a script on your own computer

Draft in review · not in the app yet

AI for game dev

By the end, you can

  • Build cheap, deterministic, debuggable game AI with state machines, behaviour trees, utility scores and flow fields.
  • Search adversarial games with minimax and alpha-beta and check searches against known answers.
  • Generate and validate procedural content reproducibly from seeds.
  • Evaluate opponents on unseen maps with replays, uncertainty and failure analysis, and report improvements honestly.

Lessons

  1. The game loop: ticks, budgets and determinismDraft
  2. Finite state machinesDraft
  3. Behaviour treesDraft
  4. Flow fields: paths for many agents at onceDraft
  5. Utility AI: scoring choicesDraft
  6. Adversarial search: minimax and alpha-betaDraft
  7. Procedural generation you can trustDraft
  8. Capstone: a grid opponent evaluated on unseen mapsCapstone projectDraft
Before you start
  • reading Python with lists, dicts, tuples and loops, and running a script on your own computer
  • graphs and breadth-first search (Autopilot Planning lessons 1-2 teach both; A* there is assumed, not retaught)
  • fractions, averages and the standard error of a proportion (AI Lab 'How LLMs work' lesson 7)
  • experience playing games helps, but no game engine is needed: every game here is a grid printed as text

Draft in review · not in the app yet

Eigen, SVD and PCA, proved

By the end, you can

  • Prove and use the spectral theorem, Courant-Fischer and Weyl's inequality.
  • Compute and interpret the SVD of any matrix, its rank, norm, pseudoinverse and condition number.
  • Prove Eckart-Young, and derive PCA from the SVD of centred data.
  • Implement and verify power iteration and a truncated SVD, with their convergence rates and failure modes.

Lessons

  1. The spectral theorem, provedDraft
  2. Rayleigh quotients and eigenvalue sensitivityDraft
  3. The SVD of any matrixDraft
  4. Pseudoinverse, least squares and conditioningDraft
  5. Eckart-Young and PCA via the SVDDraft
  6. Power iteration, proved, and a from-scratch SVD capstoneDraft
Before you start
  • the AI Lab 'Covariance to PCA' course through lesson 4 (covariance, projection, 2x2 eigenvalues by det(S - λI) = 0), or equivalent
  • matrix multiplication, transpose, determinant and trace of a 2x2 matrix
  • complex numbers a + bi and the conjugate (for one step of lesson 1's proof)
  • proof by induction
  • for the notebooks and the capstone: small Python functions with lists, run on your own computer

Draft in review · not in the app yet

Matrix calculus for backprop

By the end, you can

  • Compute gradients and Jacobians, and apply the multivariable chain rule with correct shapes.
  • Derive gradients of common matrix expressions by components and by the trace method.
  • Derive and implement the backward pass of linear, ReLU and softmax-cross-entropy layers.
  • Verify a backward pass with a gradient checker, and report what the check does and does not show.

Lessons

  1. Gradients: every direction at onceDraft
  2. Jacobians and the chain ruleDraft
  3. Gradients of matrix expressionsDraft
  4. Backprop through a batched layerDraft
  5. Softmax, cross-entropy and stable gradientsDraft
  6. Gradient checking and a from-scratch capstoneDraft
Before you start
  • single-variable derivatives: power, product and exponential rules, and the one-variable chain rule
  • vectors as lists of numbers, the dot product and vector length
  • matrix-vector and matrix-matrix multiplication, transpose, and the 2x2 inverse
  • the AI Lab 'Neural nets' idea of a loss that training makes smaller (helpful, not required)
  • for the notebooks and the capstone: writing small Python functions with lists and running a script on your own computer (no NumPy needed)

Draft in review · not in the app yet

Classic ML theory: bias, variance and generalisation

By the end, you can

  • Separate training error from risk and quantify the optimism of training error.
  • Derive and use the bias-variance decomposition, and choose regularisation from it.
  • Select models by leakage-free cross-validation and report test results honestly.
  • Use Hoeffding and union bounds to size evaluations, and know their limits.

Lessons

  1. Risk, training error and overfittingDraft
  2. The bias-variance decompositionDraft
  3. Regularisation: ridge and lassoDraft
  4. Model selection and cross-validationDraft
  5. Generalisation boundsDraft
  6. Capstone: measure bias and variance yourselfDraft
Before you start
  • least-squares line fitting and the normal equations (the 'Matrix calculus for backprop' course, lesson 3, or equivalent)
  • expectation and variance, including Var(cX) = c²Var(X) and Var of a mean of n independent copies = Var/n
  • the idea of a training set and a test set (AI Lab 'ML basics')
  • logs and exponentials
  • for the notebooks and the capstone: small Python functions with lists, the math and random modules, run on your own computer

Draft in review · not in the app yet

Optimization for machine learning

By the end, you can

  • Recognise convex problems and classify stationary points.
  • Predict gradient descent's behaviour from eigenvalues: stability, rate and conditioning.
  • Explain and quantify SGD noise, momentum's √κ gain and Adam's bias correction and scale invariance.
  • Run and report a fair, reproducible optimiser comparison.

Lessons

  1. Convexity and stationary pointsDraft
  2. Gradient descent and conditioningDraft
  3. Stochastic gradients and the noise floorDraft
  4. MomentumDraft
  5. Adam, derivedDraft
  6. Schedules, diagnosis and an optimiser capstoneDraft
Before you start
  • gradients, the chain rule and gradients of quadratic forms (the 'Matrix calculus for backprop' course, or equivalent)
  • eigenvalues and eigenvectors of a symmetric 2x2 matrix
  • mean and variance of a random quantity, and that independent variances add
  • logs and exponentials, and geometric series 1 + r + r² + … = 1/(1 - r) for |r| < 1
  • for the notebooks and the capstone: small Python functions with lists and the random module, run on your own computer

Draft in review · not in the app yet

How LLMs work

By the end, you can

  • Explain, step by step and with numbers, how text becomes tokens, how a model assigns next-token probabilities, how training changes them and how sampling turns them into text.
  • Choose between prompting, retrieval and fine-tuning for a stated need, and justify the choice with cost and evaluation evidence.
  • Build small offline tools (a BPE merger, a bigram model, a softmax with gradient check, a sampler, a retriever and an evaluation scorer) and test them, including bad input.
  • Write a reproducible evaluation report that separates answerable and unanswerable cases, states uncertainty and names its limitations.

Lessons

  1. Text becomes tokensDraft
  2. Next-token probabilityDraft
  3. Training: logits, softmax and the gradientDraft
  4. Sampling: greedy, temperature, top-k and top-pDraft
  5. From pretrained model to assistant: prompting or fine-tuningDraft
  6. Retrieval-augmented generation (RAG)Draft
  7. Evaluating LLM systemsDraft
  8. Capstone: an offline LLM behaviour reportCapstone projectDraft
Before you start
  • fractions, decimals and percentages
  • reading a small table of counts
  • probability as a fraction of counts (AI Lab Probability lesson 1 covers this)
  • exponents and the idea of a logarithm (lesson 2 reteaches ln and e^x where it is used)
  • two- or three-coordinate vectors and the dot product (AI Lab Linear algebra lessons 1-3)
  • for notebook steps and the capstone: reading and writing short Python functions, lists and dicts, and running a script on your own computer

Draft in review · not in the app yet

Reinforcement learning to PPO intuition

By the end, you can

  • Compute returns, values and Bellman updates, and run Q-learning updates with ε-greedy exploration.
  • Derive, compute and numerically check the exact softmax policy gradient, and estimate it from samples with and without a baseline.
  • Explain advantages, actor-critic and PPO's clipped surrogate, and compute them by hand.
  • Run seeded experiments over many seeds that show what baselines and clipping change, and report results without sim-to-real claims.

Lessons

  1. Agents, rewards and returnsDraft
  2. Values and the Bellman equationDraft
  3. Learning from experience: Q-learning in one lessonDraft
  4. Policies as probabilities, and the exact gradientDraft
  5. REINFORCE: estimating the gradient from samplesDraft
  6. Baselines, advantages and actor-criticDraft
  7. PPO: reusing data with a clipped updateDraft
  8. Capstone: a checked policy gradient and a clipped updateCapstone projectDraft
Before you start
  • probability, expected value and variance of a discrete distribution
  • derivatives and the chain rule; softmax (AI Lab 'How LLMs work' lesson 3)
  • gradient descent as an update rule (AI Lab Neural nets or Optimization)
  • recommended: the Autopilot Q-learning track, which teaches tabular Q-learning in depth; lesson 3 here only summarizes it
  • for notebook steps and the capstone: Python functions, lists and loops, and running a script on your own computer

What the labels mean

Written
The lesson is authored and checked, but not yet in the app.
Draft
Complete first draft, still in teaching and maths review.
Planned / Later
On the course map. Not written yet; order and scope can change.

Checks in every lesson are practice. Nothing here awards grades, certificates or mastery claims, and asking for help never costs you progress.

Join the interest list