Lessons

Before building a company brain, understand the problem it inherits. This lesson covers explicit versus tacit knowledge, Nonaka's SECI spiral, why the 1990s knowledge-management wave left rotting repositories behind, and what retrieval and LLMs genuinely changed. The answer is precise: they collapsed the cost of reading, and did nothing at all about the cost of writing.

Two methods dominate local explanation, and both perturb the input. LIME fits a small interpretable model near one prediction. SHAP borrows the Shapley value from game theory and is the unique attribution satisfying local accuracy, missingness and consistency. This lesson builds both mechanisms, compares KernelSHAP with TreeSHAP, and is precise about what a SHAP value does not mean.

A model that predicts well can still be impossible to justify. This lesson maps explainable AI: interpretable-by-design versus post-hoc, global versus local, model-specific versus model-agnostic. It covers the global workhorses (permutation importance, partial dependence, ICE), faithfulness versus plausibility, and the argument that post-hoc explanation is the wrong tool for high-stakes decisions.

When a model is differentiable you can attribute a prediction with calculus instead of sampling. This lesson covers plain saliency, Integrated Gradients and its axioms, Grad-CAM, then counterfactual explanations, which answer what would have to change rather than what mattered. It closes with the evidence that explanations can fail or be deliberately faked, and a protocol for checking yours.

Training an EBM means shaping an energy landscape so real data sits in valleys, but the intractable partition function blocks plain maximum likelihood. This lesson covers the push-down-push-up principle, contrastive methods (contrastive divergence, noise-contrastive estimation), score matching, and the regularized alternative that avoids sampling entirely.

Where digital twins earn their keep and where they struggle. This lesson covers predictive maintenance (the flagship use), applications across manufacturing, aerospace, energy, cities, and healthcare, the underlying value of experimenting safely in virtual space, and an honest account of the challenges: data, model drift, cost, security, and standards.

What a digital twin is actually made of and the forms it takes. This lesson covers the virtual model (physics-based, data-driven, and hybrid), the data layer of sensors and pipelines that feeds it, the twin taxonomy from component to process scale, the fidelity-versus-cost tradeoff, and the sense-simulate-act loop that turns a model into a working twin.

A digital twin is a virtual replica of a specific physical thing, kept in sync by live data. This lesson defines it precisely, covers its three components, its origins with Michael Grieves and NASA, the crucial distinction from an ordinary simulation, and the digital model to digital shadow to digital twin taxonomy that pins down what 'twin' really means.

Why LeCun treats energy as the common language of machine learning. This lesson shows how classification, generative models, self-supervised learning, JEPA, and diffusion all read as energy-based models, ties the contrastive-versus-regularized split back to self-supervised learning, and gives an honest account of where explicit EBMs help and where they do not.

Energy-based models replace input-to-output functions with a scalar energy that scores how compatible a configuration is. This lesson covers the energy function, inference as finding the lowest-energy answer, the energy landscape picture, the link from energy to probability via the partition function, and why this framing handles problems with many valid answers.

How to prevent collapse without negative samples. This lesson covers distillation methods (BYOL, SimSiam) that rely on stop-gradients and asymmetry, regularization methods (Barlow Twins, VICReg) that constrain the embedding's statistics, and the masked-modeling family (MAE, BERT), then ties them to JEPA and the energy-based view.

The first family to make joint-embedding self-supervised learning work: pull together two views of the same image, push apart different images. This lesson covers the InfoNCE loss, SimCLR and its reliance on large batches, MoCo's momentum encoder and queue, why negatives block collapse, and the practical costs that motivated negative-free methods.

Self-supervised learning turns unlabeled data into its own teacher. This lesson covers why labels are the bottleneck, how a pretext task manufactures free supervision, the shift from predicting pixels to learning embeddings invariant to augmentation, and the collapse problem that every method after it must solve.

How a vision-language model becomes a robot brain. This lesson covers the VLA recipe: take a pretrained VLM, add an action output, train on robot demonstrations. It walks through RT-2 (actions as tokens, web-knowledge transfer), OpenVLA (an open 7B model), and pi0 (flow-matching action experts), plus cross-embodiment, what generalization buys, and the real limits.

Two ideas that made imitation learning work: predicting a chunk of future actions instead of one step (ACT, from the ALOHA system) to blunt compounding error, and generating actions by denoising (Diffusion Policy) to capture the many valid ways to do a task. Plus the pooled multi-robot datasets, like Open X-Embodiment, that set up generalist policies.

Why modern robots learn skills from demonstrations instead of hand-written controllers. This lesson covers behavior cloning (supervised observation-to-action learning), the distribution-shift and compounding-error problem that makes it fragile, DAgger as the classic fix, and how teleoperated demonstrations became the fuel for robot learning.

What the mRNA platform can actually treat. This lesson covers preventive vaccines, personalized cancer vaccines built from a patient's own tumor mutations (with the Moderna-Merck mRNA-4157 melanoma results), and the protein-replacement and cell-therapy frontiers, plus the honest limits that still constrain the field.

A therapeutic mRNA is destroyed in the body within minutes and cannot cross a cell membrane on its own. This lesson explains the lipid nanoparticle that solves it: its four components, the ionizable-lipid trick that releases mRNA inside the cell, where the particles travel after injection, and the cold-chain limitation that follows.

Instead of manufacturing a protein, an mRNA medicine delivers the instructions and lets your own cells build it. This lesson covers the anatomy of a therapeutic mRNA, the immune problem that stalled the field for decades, and the modified-nucleoside breakthrough by Kariko and Weissman that made it work, the reason mRNA is a programmable platform.

How to move the price inside the ZOPA. Covers the anchoring power of first offers and the evidence behind it, when to open versus wait, multiple equivalent simultaneous offers (MESOs) that create and claim value at once, common tactics and their counters, and how to negotiate from a weak BATNA.

Real negotiating power comes from your alternatives, not your volume. This lesson defines your BATNA (best alternative to a negotiated agreement), derives your reservation price from it, and shows how the overlap of both sides' walkaway points, the ZOPA, decides whether a deal is even possible. With a fully worked numeric example.

Negotiation is a learnable skill, not a personality trait. This lesson separates positions from the interests beneath them, contrasts distributive bargaining (claiming a fixed pie) with integrative bargaining (creating value through trades), and introduces the principled-negotiation framework from Fisher and Ury's Getting to Yes.

How SVN handles parallel work. Covers the trunk-branches-tags convention, cheap copies that make a branch nearly free, why branches and tags are the same mechanism, merge tracking with svn:mergeinfo, reintegrating a branch, and moving between SVN and Git with git svn.

The everyday SVN commands and the model behind them. Covers the update-edit-commit cycle, status codes and diffs, the copy-modify-merge approach to conflicts, locking for unmergeable binary files, useful properties like svn:ignore, and how to undo changes safely.