Writing
Notes on AI, embedded systems, and developer tools. Some pieces live here; some were published elsewhere and are marked with the source.
2026
- Repo-DNA: distilling a codebase down to its one load-bearing bet A skill for coding agents that reduces an unfamiliar repository to a single graspable file — capturing not what it shares with every repo of its kind, but the one bet that makes it itself.
- Still think in C after 25 years, so I built a tool that explains Rust through what you already know Launching SyntaxLens to r/rust: instead of reading the docs from scratch, ownership explained in terms of the pointers and malloc/free you already have.
- Qubit, circuit, gate — none of them mean what a classical engineer expects A guitar-string metaphor for building intuition about quantum computation, and the three borrowed words that clash hardest with a classical-computing mental model.
2025
- React2Shell: the day JSON broke the server How CVE-2025-55182 turned React 19's Flight deserializer into a code compiler — climbing the prototype chain to the Function constructor, and why the real fix was two layers deep.
- From the JVM to V8 to the Agent Virtual Machine Taking the term “Agent Virtual Machine” seriously as a runtime tuned for a class of task, and reading Anthropic's Skills pattern as its module registry — metadata first, the module only on demand.
- Prompt management: from prototype to production A prompt that carries a demo becomes unmanageable the moment it has to hold production quality — and the patterns different codebases are converging on to keep them maintainable.
- The return of the command line in AI development Why a full-width prompt, a visible task breakdown, and inline diffs make a CLI stick where an IDE sidebar doesn't — AI work is execution-heavy, not edit-heavy.
- How markdown became the interface for AI-driven development The files appear in a fixed order — rules, then PRD.md, then TASK.md, then ARCHITECTURE.md — because each one is forced by a failure the last couldn't absorb. You don't adopt a process; you rediscover why one exists, at speed.
- USB port for AI: the Model Context Protocol REST tells a model what to call. MCP lets it discover what's possible — tool descriptions, parameter schemas, resources, and the prompts that guide their use.
- Beyond the prompt: the decisions that start after AI generates code You read every generated snippet, until you don't — then you're just running it, pasting logs back, and shipping. The dilemmas that matter start when the model can no longer fix its own output.
- DeepSeek R1: the AI that learns like a master baker Four terms — R1-Zero, GRPO, rejection sampling, Mixture-of-Experts — that obscure more than they explain, unpacked through a baker perfecting a recipe.
- The new developer reality: thriving in the AI age The expectation was thinking less. What actually happened was thinking more — the work moved off writing the logic and onto deciding what you want and judging what came back.
2024
- Kernel Sage: what if the codebase explained itself It's easier to understand something when a friend explains it than when you read the book. So what if the Linux kernel could talk — a CLI where you ask a subsystem to describe itself.
- The awakening of cells One prompt — a parable about cells that already know what to do — given to three models. Claude answered with a fable, o1-preview with self-help bullets, GPT-4o with a structured explainer.
- If we generate code, do we still need code? If intent is the thing you actually author, the specification becomes the source of truth and the code becomes an intermediate output — the way assembly already did.
- Making syntax learning easy: transforming code between languages with AI and Manim Animating the transformation of a program from C++ into Rust, so the unfamiliar language is learned as a delta from the familiar one rather than from scratch.
- Old world, new world: what's worth protecting when code is cheap When the implementation was the scarce thing, you kept the code secret. When it isn't, the moat moves to system design, data, and the expertise to execute.
- Git and mind Memory as commits — deltas, not whole copies. Recall as hashing on a smell or a mood. Beliefs that branch, conflict, and merge. The mind described in the one version-control system its readers already know cold.
- Nobody codes now, everybody reviews If the developer's job is reviewing generated code, what is the code reviewer's job — reviewing already-reviewed generated code? The regress is a joke with a real problem inside it.
- The secret behind Cursor's power Two weeks in Cursor, against Copilot, GPT-pilot, GPT-engineer and Aider. The win isn't the model — it's Composer holding context across many files, and a hundred small choices about where the panel sits.
- How AI made understanding a new codebase effortless Four ways to make an unfamiliar codebase legible — collapse it to one runnable file, reduce it to pseudocode, ask the model to narrate its history as a code historian, or have it emit a sequence diagram.
- How can a word ask a query? Inside self-attention Every explanation of self-attention hands you Query, Key and Value already formed. This one works backwards: what problem would make someone invent them.
- How do LLMs learn? Loss functions, and learning from mistakes Loss as the distance between what you aimed for and what you hit — worked up from missed free throws to the objectives that actually train a model.
- What are LLMs really learning? A ladder from binary logic up to the weights of a 405B model, ending where most explanations don't bother to go — what the numbers actually are in RAM, and what file they sit in on disk.
- Strategic keywords for debugging with an LLM Adding two words — “think critically” — measurably changed the quality of debugging answers. A record of what prompting took before models did the deliberating themselves.
- Comparing traditional computing with LLMs Fourteen mappings from the machine he spent twenty-five years inside to the one he was learning — attention as memory access, context window as cache, fine-tuning as a microcode update.
- How neural networks learn to stay positive: ReLU One of the simplest rules in machine learning — pass positive values through, zero everything else — and why running it across a whole tensor at once is the point.
- An information plane without brakes Prompting is like piloting an information plane without brakes. The hard part is knowing where to halt.
- A developer's view of prompting Eleven mappings from the parts of a prompt to the parts of a program — verbs as functions, conditions as if-statements, constraints as assertions.
- Reading code is easier than reading large prompts Reading code feels more comfortable than reading large prompts. Is AI increasing complexity or decreasing it?