Blog
Thoughts on software development, Rust, and systems programming.
the bottleneck in prompt engineering is the engineer
You can't improve a prompt faster than you can read failures and generate hypotheses. There's a way to take yourself out of that loop.
Fine-tuning my own model for the scraping agent — first attempt
After weeks testing general-purpose models, I realized the problem wasn't which model I picked. It was that planning, extraction, and enrichment are three completely different tasks that no general model is optimized for. So I started fine-tuning my own.
Testing every model I could find to make an autonomous scraping agent work
I'm building an endpoint that autonomously searches, scrapes, and extracts structured data in a loop. Getting an LLM to drive that loop reliably turned out to be the hardest part.
Building a SaaS in Go without a single React component
How I shipped a pay-per-use web scraping platform using Go, templ, and HTMX — no frontend framework, no node_modules in the critical path.
1.1MB Lighter: A Performance Cleanup That Actually Mattered
From Lighthouse 72 to 100 by removing things instead of adding them. 37 files deleted, zero regressions, and a hidden bug that made all text invisible.
From OOM to 76 Passing: Arena Allocation and ASI in a PEG Parser
How an arena allocator gave a 57× speedup, and why I had to invent a new PEG assertion to handle JavaScript's semicolon insertion.
Validating Real-World JavaScript with a PEG Grammar
Testing the ES2025 grammar against 69 production JS files — what broke, what worked.
The Arrow Function Lookahead Trick
How balanced-paren scanning before => gave a 38% speedup in my PEG parser.
57 new() Calls, 2 free() Calls
Porting from Go to Odin — what happens when you bring GC assumptions to manual memory.
Building a TUI From Scratch in Odin
Raw termios, alternate screen buffer, differential rendering — no libraries.
The Elm Architecture in a Systems Language
Implementing TEA (Model-Update-View) in Odin for a TUI — without closures or generics.
Why I Built a Shell Config Manager
The problem with monolithic .zshrc files and how Wayu fixes it.
AI Agents as Coworkers, Not Tools
The inversion of control pattern — letting AI drive workflows while using FSM as GPS.
Building 7 MCP Servers for a Frontend Factory
How we gave AI agents access to GraphQL schemas, design systems, and browser automation.
Decomposing a Monolith into Smart Surfaces
The 4-stage pipeline: catalog → spec → prototype → surface.
Migrating from REST to GraphQL in Production
N+1 queries, 403 errors, debouncing, and the real-world pain of API migration.
Tagged Unions Are All You Need
Why Odin's tagged unions replace interfaces, inheritance, and visitor patterns.
Writing a Bytecode VM for PEG Parsing
34 opcodes, explicit backtracking via stack, and how it differs from recursive descent.
Self-Hosting a Parser: The Bootstrap Problem
How Pegasus uses a meta-grammar to parse user PEG grammars — a miniature compiler bootstrap.
The PATH Management Problem Nobody Talks About
Why v2's approach broke and how v3's array-based system fixed it.
The Strategy Pattern Without Objects
Using function pointers in Odin to build a generic config CRUD system.
Wiring Vue Components to GraphQL
Patterns for connecting Nuxt 3 micro-apps to a GraphQL domain gateway.
Making a Design System AI-Readable
Publishing 6K+ component docs as MCP resources so AI agents can use them correctly.
Migrating from Cypress to Playwright
Why we switched, the migration patterns, and how coverage went from 40% to 90%.
Building Real-Time Chat with Go and WebSockets
gorilla/websocket, RabbitMQ for the stock bot, and why decoupled microservices matter.
Load Testing a Chat Server with k6
6 scenarios: connection storms, active chat, stock bot stress, spike tests, soak tests.
Writing a Build System in 10 Files
Why I built bld — type-safe compiler flags, self-rebuilding scripts, and flat packages.
Building a Fuzzy Finder in Raw Terminal Mode
1,068 lines of Odin: raw termios, scoring algorithms, and incremental search.
An ANSI Styling Pipeline in Odin
Three-tier adaptive color: TrueColor → ANSI256 → ANSI, auto-detecting terminal capabilities.
25 Micro-Apps in One Nuxt Shell
How Upwork's Smart Surfaces architecture works — SPA bundles, App Shell, shared auth.
Packrat Memoization with AVL Trees
Selective memoization, memory/speed tradeoffs, and AVL-balanced interval trees.
Eliminating Left Recursion in PEG Grammars
Why PEG can't handle left recursion natively, and the iteration-based rewrite patterns.
Rate Limiting and Auth Hardening in Production
Brute-force protections that reduced unauthorized access by 80%.
Arena Allocators: The Simple Solution to Memory Management
Why arenas are the 80/20 of memory management — two lifecycles, zero complexity.
Shipping an Ads Unit from Concept to Production
Cross-functional coordination — frontend, backend, analytics — building a new revenue stream.
Why I Write Odin
Data-oriented design, no hidden control flow, manual memory without the pain.
Processing images in rust
Here I try to understand how images work down to the bytes
Building a simple http server in rust
Getting a better understanding of http