Cursus

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.

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.

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.

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.

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.

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.

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.

What a qubit actually is mathematically, how entanglement and circuits compose, the hardware approaches and their trade-offs, why error correction is the central engineering problem, where algorithmic quantum speedup lives, and how cryptography adapts. Six lessons, math-load-bearing, with no predictions about timelines.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.