From theory to the systems that demand real understanding.
Long-form pieces on how production-AI teams orchestrate agents, serve models, and build the stack, plus GATE DA essays that turn probability, linear algebra, DBMS, ML, and AI into durable concepts.
Your t-SNE plot is lying to you (three ways)
t-SNE and UMAP reveal clusters PCA hides — but cluster sizes, the gaps between clusters, and even the shapes are often artifacts. How to read these plots without fooling yourself, and when to reach for UMAP instead.
For some AI deployments, deliverable electricity is becoming a binding co-constraint
For some AI deployments, deliverable electricity is becoming a binding co-constraint. Why data-center power matters, and how inference makes every AI query an energy cost.
Attention is O(n²) — and Mamba's linear escape
Attention costs O(n²), so long context gets expensive fast. State-space models like Mamba do linear sequence work at fixed dimensions, which can make some very long streaming workloads more tractable. Some long-context workloads may favor hybrid designs, but quality, latency, memory, and cost must be measured.
Beyond next-token: world models and the next paradigm
World models predict the next state of an environment, not merely the next token. See how action-conditioned prediction supports planning, and where visual and latent approaches fail.
Diffusion language models: when AI writes text all at once
Masked discrete diffusion language models often start from a masked sequence and refine many positions in parallel over several sequential denoising passes.
Reading a model's mind: sparse autoencoders explained
Sparse autoencoders pull human-readable features out of an LLM's tangled activations — the breakthrough tool of mechanistic interpretability.
How reasoning distillation gives small models stronger math and code behavior locally
A practical guide to teacher signals, verified reasoning traces, supervised fine-tuning, evaluation, and serving small reasoning models on local hardware.
DPO vs PPO-based RLHF: when offline preference tuning wins
RLHF aligned chat models with a reward model and a fragile RL loop. DPO drops both, learning the same preferences directly from chosen-vs-rejected pairs.
Small models for narrow tasks: when they beat larger models
When a small language model can match or outperform a larger one on a stable, measurable task slice—and when that claim fails.
Why a deployed model does not learn from a chat—and how fine-tuning can cause forgetting
A deployed checkpoint normally does not update its weights from a conversation unless an explicit memory or update loop exists. Fine-tuning on sequential data can cause catastrophic forgetting, meaning degraded old-task performance, but does not necessarily do so. Why continual learning remains an open problem in 2026.
Test-time compute: why thinking longer beats thinking bigger
Test-time compute lets a model think before answering, so a small reasoning model can beat a far larger one. How inference-time scaling works.
A/B testing in practice: sample size, p-values, and the traps
A/B testing done wrong wastes months of effort. Master p-values, sample size, and the six traps — peeking, SRM, and more — before your next experiment.
Cohort analysis: how to actually read a retention curve
Cohort analysis reveals what aggregate retention metrics hide — learn to build a cohort table, read a retention curve, and spot product-market fit signals.
Evaluating forecasts: MAE, RMSE, MAPE, and honest backtesting
A practical guide to forecast accuracy using MAE RMSE MAPE and MASE, plus rolling-origin backtesting to avoid self-deception in time series.
find and xargs: bulk file operations without fear
Master the find command and xargs for safe, efficient bulk file operations: handle spaces in filenames, batch deletes, renames, and parallel processing.
The forecasting baselines that quietly beat fancy models
Why forecasting baselines like the naive forecast and seasonal-naive outperform complex models—and how to pick the right one before you build anything fancy.
Funnel analysis: finding exactly where users drop off
Master funnel analysis to pinpoint conversion leaks, prioritize fixes by impact, and turn step-by-step drop-off data into real growth.
git bisect: find the commit that broke it in log(n) steps
Use git bisect to find the exact commit that introduced a regression or bug with binary search over history — O(log n) instead of O(n).
Branching strategies that scale: trunk-based vs Git Flow vs GitHub Flow
Compare every major branching strategy: trunk-based development, Git Flow, and GitHub Flow — and know which fits your release cadence.
Git merge vs rebase: when to use which (without wrecking history)
Git merge vs rebase both integrate branches but produce different histories. Learn when each is right, the golden rule, and how to recover when things go wrong.
Git's three trees: the mental model that makes Git click
Understand git's working directory, staging area, and HEAD so every git command finally makes sense — no more mystery, no more fear.
grep, sed, awk: the text-processing trio worth mastering
grep sed awk command line text processing explained: when to use each tool, real recipes, regex fundamentals, and how pipelines compose all three.
LTV and CAC: the unit economics every analyst should model
Master LTV and CAC unit economics: correct formulas, cohort methods, payback periods, and the pitfalls that make most models wrong.
North Star metrics: the one number that actually moves a business
What a north star metric is, how to choose one, and why a single well-chosen number beats a dashboard of 40 KPIs.