Series
All Series
Ordered sequences of posts — read from start to finish.
AI Foundations
AI explained from zero. What AI, ML, and deep learning actually are, what a model is, how training and inference differ, and the real meaning of LLMs, context windows, RAG, and fine-tuning.
- 01
AI, in plain words
What "AI" actually means, where the term came from, and why every product calls itself AI now. Sets up where machine learning and deep learning fit underneath.
- 02
Inside AI: machine learning and deep learning
Open the AI umbrella. Machine learning is the part that learns from data. Deep learning is ML done with neural networks, and that's where today's models live.
- 03
What makes a model: data and algorithm
A model is a file of learned numbers, produced by running an algorithm over data. Both ingredients matter, but bad data beats a good algorithm every time.
- 04
How a model learns: training and inference
Training is the expensive one-time event where a model's numbers get tuned. Inference is the cheap repeated use afterwards. The gap in cost is enormous, and it shapes the whole industry.
AI Running
Where AI actually runs and what it costs. Cloud vs local vs edge, the major models in 2026, what your laptop needs to host them, the runtimes, API token economics, and what really leaves your machine.
- 01
Where AI actually runs: cloud, local, edge
When you use AI, a model file is sitting on a real machine. There are only three places it can be, and which one decides almost everything else.
- 02
The major LLMs in 2026
A field guide to the closed frontier models and the open weights you can actually run. What the "B" numbers mean, and which size fits your machine.
- 03
What it takes to run a model on your own machine
Why VRAM is the one number that decides whether a local LLM runs, what quantization really does to a model file, and the hardware ladder from an 8GB laptop to a 192GB workstation.
- 04
Why Apple Silicon punches above its weight on local LLMs
Unified memory lets the GPU see all of RAM. Here's why that beats a discrete-GPU PC past 32B parameters, what fits in 16/32/64/128/192GB, and where Apple Silicon still loses.
Local Llms
Run a useful LLM on the laptop you already have. Hardware tiers, model picks, runtimes, RAG and tools, fine-tuning, and how to debug it when it breaks.
- 01
The pitch for local LLMs in 2026
The case for running an LLM on the machine you already own. Privacy, no per-call cost, faster first token, no rate limits, and it works on a flight.
- 02
The local-LLM vocabulary
Parameters, B, dense vs MoE, base vs instruct, tokens, context windows, chat templates, GGUF, and quant suffixes. Read it once and any HuggingFace model card stops being scary.
- 03
Quantization, distillation, pruning: how a 140GB model fits on your laptop
Three ways to shrink an LLM, and why one of them does almost all the work. What Q4_K_M actually means and what each shortcut costs you.
- 04
Streaming, throughput, and the KV cache
Why TTFT and tok/s are different numbers, why streaming feels faster than it is, and the KV cache that makes the 1000th token cost about the same as the first.
Setup Toolbox
One-stop install guides for the CLI tools every other post on this blog assumes you have. Cross-platform: macOS, Linux, Windows. Each post covers install, configure, verify, and the gotchas.
- 01
Install Homebrew
The one-line Homebrew installer for macOS, Linux, and WSL, plus the PATH step Apple Silicon needs and a quick way to check it actually took.
- 02
Install Git
Install Git on macOS, Linux, and Windows, set your name and email so commits get attributed to you, and confirm it all worked in one command.
- 03
Install Node.js and npm without future regret
Install Node and npm through a version manager so you can switch versions per project. fnm is my pick, with nvm and Volta as alternatives.
- 04
Install Python the right way, with uv
Leave system Python alone. Install uv, then let it handle Python versions and per-project virtual envs from one fast binary.