Every dispatch.

Structured output: making a text generator return typed data

Structured output is constrained decoding: before the sampler picks, a schema-compiled state machine masks every token that would break your JSON, making invalid shape mechanically impossible. Three tiers of guarantee, why tool calls are the same machinery, and the quality tradeoff nobody warns you about.

Streaming: publishing, not generating

Streaming doesn't change how a model generates—only how the server delivers what it was already producing one token at a time. What SSE actually is, why TTFT and ITL are different problems, and the engineering a stream forces on you.

Temperature and sampling: the dice live outside the model

The model emits a fixed probability distribution; everything that feels random happens in the sampler on top of it. What temperature actually does, how top-k/top-p/min-p differ, and why 'temperature 0' isn't truly deterministic.

Roles are a convention, not an architecture

System, user, and assistant are special tokens in one flat sequence that the model was post-trained to honor — not privileged channels. Why the instruction hierarchy is a learned preference, and why that's exactly why prompt injection works.

Context windows: the only door into a frozen model

A frozen model has exactly one write surface — the context window. Why it's bounded, why its usable length is far shorter than the number on the model card, and why deciding what to put in it is the core skill of working with LLMs.

Dev Log: Building Groundwork

Dogfooding Groundwork's requirements workflow on Codagatchi: the baseline it generated, and — graded against my requirements research — exactly where the gaps are to fix next.

A house style for AI-generated cover art

Generating an image is one API call. Keeping ~48 of them on-style across months is the actual work — here's the house style, the model bake-off, and the pipeline that makes it reproducible.

Why models hallucinate

Hallucination isn't a bug grafted onto a truthful system — it's the default behavior of a next-token predictor. The same operation produces every correct answer and every confident fabrication. Why it happens, and why grading rewards it.

What training actually means

Training an LLM isn't one step — it's a pipeline. Pretraining (99% of the compute) gives the model its knowledge; post-training (SFT, RLHF) shapes how it behaves. A ground-up map for engineers.

Knowledge cutoffs: the model thinks it's still last year

A knowledge cutoff isn't a date on a sticker — it's the trailing edge of a distribution, and the model can't reliably see its own boundary. Why frozen weights make every chat a conversation with an archive, and what actually moves the line.

Inference vs. training

Once training ends, the weights freeze. Inference is the read-path — a forward pass run one token at a time, forever. Autoregressive decoding, prefill vs. decode, the KV cache, and the five ways inference differs from training.

What a neural network actually is

A neural network is a function with billions of tunable weights fit from examples by an optimizer — not a brain simulation. A ground-up explainer for software engineers on how they actually work.

LLM Driven SDLC: How AI Is Reshaping the Way We Build Software

An introduction to the series — how large language models are changing every phase of the software development lifecycle, from requirements to deployment.

Shipping a devblog with Claude Code and Linear

Why I use Linear for a one-person project, and how superpowers skills and git worktrees make Claude Code feel like a real teammate.

How modern LLMs are trained, end to end

Building a frontier large language model today is a three-act play: a massive pretraining phase that absorbs the internet, a post-training phase that turns the resulting "completer" into a helpful assistant, and an increasingly important reinforcement-learning-on-reasoning phase that teaches the model to think before answering.

Designing the design stage: a comprehensive synthesis for an LLM-driven architecture plugin

A practical playbook for the architecture/design stage of an LLM-driven SDLC plugin: what makes design artifacts good, a file-per-artifact schema that mirrors the requirements layer, a methodology-agnostic core (ISO 42010 + arc42 + C4 + MADR + SEI), and a multi-agent pipeline with deterministic validation gates.

The physical layer of the AI revolution

Training a frontier large language model is no longer a software problem — it is a construction problem. The binding constraints have shifted from chips to power, packaging, and grid interconnects, with transformer lead times stretching past three years and over half of planned 2026 US data-center capacity reportedly delayed by electrical-equipment shortages.

Designing an LLM-Driven Requirements Generator

How to build an LLM-powered requirements generator using EARS notation, ISO 25010:2023 NFR coverage, and a multi-agent generator/critic/formatter split that avoids the failure modes empirical studies now document.

Tokens, Tokenizers, and How Claude Counts Them

How subword tokenization algorithms work under the hood, why they shape context window economics and model accuracy, and what Claude's proprietary tokenizer changes mean for your API budget.

Why your Claude Code agents need a BOUNDARIES.md

Three weeks fighting yes-man behavior, and the small architectural guardian that finally fixed it.

Building an MCP server for Godot: lessons from week one

Whole-project analysis, debug interpretation, and the parts I got wrong.

Configurable approval modes for background tasks

A YAML pattern for auto / review / approve workflows that scales beyond a single agent.