All Posts
Does Haiku Fan-Out Replace Sonnet? Two Experiments in Code Review and Solution Discovery
I swapped the five Sonnet hunters in my code review pipeline for Haiku across 14 PRs with known bugs. Haiku found 20 of 26 defects to Sonnet's 21, produced 61% more raw findings, and used 28% more tokens. In a second test, 8 Haiku advocates plus an Opus adjudicator reached the same design family as 3 Sonnet advocates on all 3 decisions. The result: near-parity on recall, but no cost advantage in a validation-heavy pipeline.
Why I Built a Compaction System Instead of Handing Off to New Agents
When a long-running orchestrator hits context limits, the obvious move is to hand off to a fresh agent. I tried that. The startup overhead, lost momentum, and broken continuity made it worse than the problem it solved. So I built a daemon-managed compaction system instead: one that monitors context usage, writes ground truth to disk, runs a four-stage idle-gated restore protocol, and distills session knowledge into a wiki page. The daemon is the sole compaction authority; seats never self-compact. Recent research shows neither approach is categorically better, but for same-model orchestrators that accumulate judgment over time, daemon-managed compaction with external ground truth wins.
Surviving the Dumb Zone: A Checkpoint System for Claude Code's /compact
Claude Code's /compact command compresses your conversation to free context, but it silently drops external state mutations, abandoned approaches, and behavioral constraints. I built a precompact/postcompact checkpoint system that writes ground truth to disk before compaction and cross-checks it afterward — including live reconciliation against git, CI, and external systems. Here's the design, the research behind it, the failure modes it prevents, and how OpenRig's native compaction system eventually superseded these custom skills.
Building an Observer That Turns Claude Code Sessions into a Knowledge Base
Every Claude Code session produces decisions, patterns, and context that vanish when the terminal closes. I built a daemon that watches for session endings, extracts the knowledge, distills it with Haiku, and compiles it into an Obsidian wiki with Sonnet — turning every coding session into searchable institutional memory for about $20/month.
Claude Code Research Tools: A Decision Guide
Claude Code has a dozen ways to research a question — from a single MCP call to a 98-agent adversarial pipeline. This guide maps every research tool by cost, agent count, and use case so you pick the right one the first time. Includes the full source of a custom deep-research-plus workflow that adds a Perplexity search lane to Claude Code's built-in deep-research pipeline.
The Attention Mechanism: Context Rot and the Lost-in-the-Middle Problem
LLM context rot isn't a bug. It's a mathematical property of how the attention mechanism works. Three interacting failure modes (softmax's sum-to-one constraint, RoPE's distance decay, and causal masking's primacy bias) combine to produce the U-shaped attention curve where models attend well to the beginning and end of context but lose the middle. Understanding the mechanism changes how you structure prompts and manage context.
The LLM Dumb Zone: Performance Degradation Before the Context Limit
LLM context windows have a marketed size and a useful size, and they're not the same number. Research shows quality degrades gradually based on absolute token count, not fill percentage, and a 1M-token model at 40% full is far more degraded than a 200K model at 40%. Here's the research behind the Smart Zone, the Warn Zone, and the Dumb Zone, plus a Claude Code statusline that tracks which zone you're in and how deep.
Benchmarks vs Vibes: Opus 4.6 vs Opus 5 for Daily Coding
Opus 5 scores 96.0% on SWE-bench Verified vs Opus 4.6's 80.8%, a 15-point gap. But on blind user-preference coding leaderboards, Opus 4.6 ranks 4th (ELO 1547) while Opus 5 ranks 11th (ELO 1530). Synthetic benchmarks and human preference are telling opposite stories. I ran a two-round adversarial research workflow to figure out which signal to trust and landed on a mixed-model strategy.
Near-Miss Retrieval in RAG: Semantic vs Hierarchical Chunking
The retrieval pipeline returned chunks that mentioned vaccination schedules but didn't contain the actual schedule data. The model saw evidence that was on-topic but empty of the answer - and correctly refused. The root cause wasn't the model, the reranker, or the query. It was the chunking strategy splitting tables and structured data away from the prose that named them.
Stochastic Refusal in RAG: Same Evidence, Different Answer
Same question, same branch, same retrieval, same 10 evidence chunks with identical rerank scores - and one deployment refused while another answered with full clinical detail. The root cause wasn't retrieval. It was the LLM making a borderline judgment call on evidence that covered half the question well and the other half barely at all.
Reranking in RAG: Cross-Encoder Scoring for Recall and Precision
Vector search finds the right chunk but ranks it badly and waves through near-garbage that's vaguely on-topic. Reranking fixes that with a second model - a cross-encoder that reads the query and each chunk together instead of comparing two frozen vectors. The whole trick is affording an expensive judge by only running it on the cheap stage's survivors.
Setting Up Python with uv
A guide to set up a modern Python development environment using uv, the fast all-in-one tool from Astral that replaces pyenv, virtualenv, and Poetry.
Module-Load Env Guards in Next.js: Structural Validation Beyond process.env Checks
Most env-var validation checks that values exist. That catches missing config but misses the worse case - a value that is present, valid in shape, and silently wrong. Here is the asymmetric pattern for separating loud failures from silent ones in a Next.js server.
Producer, Service, ProducerService: Interface Segregation for Shared Singletons in Go
When one Go struct legitimately serves multiple consumer roles - producer, service, admin - declare three interfaces and let DI cache the singleton at the wide type while each consumer holds only the methods it can call. Same shape as io.ReadWriteCloser in the stdlib.
Idempotent SQS Workers with Postgres UPDATE: The WHERE-Status Pattern
Most SQS idempotency guides reach for Redis dedupe keys or dedupe tables. If your worker's job ends in a terminal state-machine transition, the row's own status column is already the lock - and one UPDATE statement is the entire safety story.
Agentic Engineering at Airvet: Research, Plan, Implement
A talk I gave to the Airvet engineering org on working with AI coding agents - the mental model, context engineering, and the Research → Plan → Implement loop that ties them together.
Setting up Global MCP Configuration for Claude Code
Learn how to configure MCP (Model Context Protocol) servers globally for Claude Code, making them available across all your projects.
AI "Overview": GPT, RAG, and How They Actually Work
A talk I gave to the Airvet engineering org as a primer on AI - what GPT and RAG actually are, how neural networks, tokens, and embeddings fit together, and why the difference matters.
Preparing for ESLint v9: TypeScript Integration Changes
A guide to the upcoming changes in ESLint v9 regarding TypeScript integration, including migration notes.
Tackling 'on load' Scrolling in Chat Applications
How to solve one of the most frustrating UX issues in chat applications: ensuring automatic scrolling works correctly when images load asynchronously.
Why useRef Doesn't Work for Dynamic Element Measurements
Why useRef alone is insufficient for dynamic measurements, and how to combine it with ResizeObserver and useState for responsive UI.
Proxy Firebase Auth with Next.js on Vercel
Solving Firebase Auth redirect issues on Vercel by implementing a proxy solution to handle SAML SSO authentication and resolve missing initial state errors.
Go Idioms: Accept Interfaces, Return Types
Understanding the Go idiom of accepting interfaces and returning concrete types to write flexible, reusable, and maintainable code.
Allocating Memory in Go
Understanding memory allocation in Go, including stack vs heap allocation, escape analysis, and how Go handles pointer returns from functions.
Methods in Go
Understanding Go methods, the difference between value and pointer receivers, embedding for composition, and how interfaces work with methods.
Slices in Go
Understanding Go slices, their underlying array structure, creation and modification mechanics, and the implications when passing slices to functions.
JSON Encoding and Decoding in Go
A guide to JSON serialization and deserialization in Go, covering type mappings, HTTP responses, and practical examples with the net/http package.
Go Function Argument Passing Behavior
How Go passes function arguments by value and the implications for different data types: integers, pointers, slices, strings, and structs.
Tailwind CSS Unknown at Rule
Fixing VSCode warnings for Tailwind CSS directives by creating custom CSS data configuration files for proper syntax recognition.
NVM Commands Cheatsheet
A comprehensive cheatsheet for Node Version Manager (NVM) commands including installation, version switching, aliasing, and management.
Understanding Interfaces in Go
A guide to understand Go interfaces through a power socket and electrical device analogy, covering duck typing and interface implementation.
Recover from a git push --force
How to recover from an accidental git push --force by using git reflog to find the previous commit and restore the branch to its original state.
Using SVGs with Next.js 11 and TypeScript
Fixing TypeScript ESLint errors when using SVGs with Next.js 11 by creating custom module declarations and configuring TypeScript properly.
Basic Data Structures in Go
Understanding Go data structures and their memory layout including integers, floats, arrays, pointers, structs, strings, and slices.
Find and Kill Process on Port 3000
How to find and kill processes running on specific ports like 3000 on macOS using lsof and kill commands.
Indexing Strings and Runes in Go
Understanding the difference between indexing strings as bytes versus runes in Go, and when to use each approach for proper Unicode handling.
Setting Up Husky, Prettier, and ESLint with precise-commits and lint-staged
Automatically format and lint code with Git hooks using Husky, Prettier, ESLint, precise-commits and lint-staged for pre-commit and pre-push workflows.
Understanding JavaScript Promises: Chaining, Error Handling, and async/await
A practical guide to working with JavaScript Promises - from basic chaining and resolve/reject behavior to .catch, Promise.all fail-fast handling, and async/await error patterns.
The io.Reader and io.Writer Interfaces in Go
Understanding the io.Reader and io.Writer interfaces in Go, and how accepting an io.Writer parameter makes your code flexible across files, HTTP responses, stdout, and in-memory buffers.
Self-Hosting a Go Binary on AWS EC2
Deploying a Go service to a single AWS EC2 instance as a hardened systemd service - cross-compiling the binary, copying it across, creating a non-root service user, configuring systemd with the right hardening directives, and handling graceful shutdown.
ESLint on TypeScript and JavaScript Files
Setting up ESLint to parse and lint a mixed JavaScript and TypeScript codebase using overrides configuration for different file types.
Accessing Material UI Theme Object in Emotion JS
A guide to access and utilize Material-UI theme objects within Emotion styled components and CSS props, with practical implementation examples.
Configuring AWS Email Billing Alerts with CloudWatch
A detailed guide to setting up automated email billing alerts in AWS using CloudWatch metrics and SNS notifications for cost monitoring.
Securing AWS API Gateway Endpoints (Cognito, IAM, API Keys)
A guide to implement authentication and authorization in AWS API Gateway, covering Cognito User Pools, IAM roles, and API keys with practical examples.
Set Breakpoints to Locally Debug AWS Lambda
A step-by-step guide to setting up and using breakpoints for local debugging of AWS Lambda functions, improving serverless development workflow.
Export Serverless Framework Environment Variables to a Local .env File
Bridging CloudFormation-generated runtime values - DynamoDB table names, API Gateway URLs, ARNs that do not exist until deployment - into a local .env file using the serverless-export-env plugin.
Reference AWS Lambda API Endpoints in serverless.yml
A detailed guide to using Serverless Framework pseudo parameters for referencing Lambda functions and other AWS resources in your serverless applications.
Add Custom AWS YAML Tags in VS Code
Learn how to set up VS Code to properly recognize and validate custom YAML tags used in Serverless Framework configuration files.
Understanding the Browser Rendering Pipeline: Layout vs Paint vs Composite
How the browser turns CSS changes into pixels - the five stages of the render pipeline, why some CSS properties trigger the full pipeline and others skip most of it, and how to avoid jank by understanding which path your changes take.
HTTP Cache-Control: ETag, Revalidation, and the Two Caching Strategies
There are two caching strategies on the web: fingerprinted-immutable URLs and server-revalidated mutable content. Pick one per resource. Most caching confusion comes from conflating no-cache, no-store, and must-revalidate.