This article traces the path from RNNs to transformers, explaining why attention-based, non-recurrent architectures replaced older models. It then breaks down encoder vs decoder designs and shows how GPT’s decoder-only approach and tokenization power today’s large language models.

• Transformers replaced RNNs by dropping recurrence entirely, using self-attention to compute all token relationships in parallel and eliminating both the sequential bottleneck and vanishing/exploding gradient issues.
• The original transformer architecture split into two lineages: encoder-only (BERT) for contextual understanding, used in Google Search ranking, and decoder-only (GPT) for text generation.
• GPT's scale jumped dramatically across versions—GPT-2 had 10x GPT-1's parameters/data, GPT-3 scaled another 100x—and GPT-3 showed strong zero-shot/few-shot performance without needing task-specific fine-tuning.

This article breaks down how an LLM turns your prompt into streamed tokens, covering tokenization, embeddings, transformer attention, and the two-phase pipeline of compute-bound prefill and memory-bound decode. It explains KV caching, quantization, and metrics like Time to First Token and Inter-Token Latency to show why inference speed depends on both compute and memory.

• LLM inference splits into compute-bound prefill (TTFT) and memory-bound decode (ITL), which explains why the two phases have fundamentally different performance bottlenecks.
• KV caching avoids quadratic recomputation but costs real memory—about 1 MB per token for a 13B model, so a 4,000-token context burns 4 GB of VRAM.
• Techniques like INT8/INT4 cache quantization, token eviction, and paged cache management exist specifically to tame this KV cache memory growth.
• DeepSeek's V4 cuts KV cache size by 90% at a million-token context by combining sparse and dense compressed attention.

This article breaks down the core concepts behind LLMs—from next-token prediction training to tokens, vectors and attention layers—to show how they generate text. It also covers context windows, parameters and why model scale affects performance.

• LLMs work purely through next-token prediction learned by hiding and guessing words billions of times during training, not through actual understanding of letters or math.
• Context windows now range wildly, from 200K tokens (~150K words) up to Llama 4 Scout's 10 million tokens, but bigger windows don't fix factual errors or logical gaps.
• Because models process text as tokens/vectors rather than raw letters, they inherently struggle with tasks like counting letters or doing arithmetic.

This article examines the high rate of unused and broken dashboards in organizations, highlighting how they often fail to provide lasting value. It discusses the disconnect between dashboard creation and actual usage, driven by shifting priorities and limited attention spans within teams. The piece also touches on the implications of this phenomenon for organizational behavior and project management.

• About half of an org's dashboards audited turned out to be broken or ignored, raising the question of why they were built at all.
• Dashboards act as "grave markers" for past priorities—built for a moment of attention that fades as new projects compete for focus.
• Letting teams self-manage their own dashboards helped somewhat, but didn't solve the core problem since attention still shifts away as new initiatives emerge.
• Organizational attention is a genuinely limited resource (with academic grounding), so strategic planning that overcommits people guarantees old dashboards get abandoned.

This article introduces the Gemma 4 family of models from Google DeepMind, detailing their architectures and improvements over the previous version, Gemma 3. It highlights key features such as interleaved attention layers and efficiency enhancements in global attention mechanisms.

• Gemma 4 comes in four sizes—E2B, E4B, 31B, and a 26B MoE model that only activates 4B parameters at inference—and handles text, images, and audio
• Local-to-global attention layers are interleaved at a fixed 4:1 ratio in smaller models and 5:1 in larger ones, with sliding windows of 512 tokens (E2B/E4B) or 1024 tokens (larger models) to cut compute costs
• Global attention memory use is reduced through Grouped Query Attention, a K=V trick that makes keys and values identical, and p-RoPE for improved positional encoding