Notes from
the build.
Essays on shipping software, on-chain data, AI in real engineering, game dev, and the messy parts nobody puts in the README. 76 posts and counting, new ones most days.
Browser game asset streaming: the first playable frame is the whole budget
Browser game asset streaming is a load-order problem, not a compression one. What I ship before the first playable frame, what waits, and how to avoid the mid-game hitch.
Session keys and the frontend: the session ends before your UI notices
Session keys stop the wallet popups, then die quietly. The four ways a session ends, why your UI is the last to know, and what I would build instead of a connected boolean.
Dynamic tool selection: why loading every tool wrecks your agent's accuracy
Load every tool into an agent and tool-calling accuracy falls off a cliff. Why more tools make the model guess, and how I filter the toolset at runtime with retrieval.
React Server Components did not kill the waterfall, they moved it to the server
RSC does not delete the data waterfall, it moves it server-side where devtools no longer show it. How the server-side staircase forms, and how I unwind it.
Websocket backpressure in the browser: the client cannot ask you to slow down
Websocket backpressure does not exist in the browser client. Why a fast feed drowns a slow tab, and the pacing patterns I use to keep live UIs honest.
Streaming made my CLS worse: the Suspense boundary was in the wrong place
Streaming fixed my LCP and hurt CLS. Why matching skeleton heights does not work, and how Suspense boundary placement decides your layout shift.
What an intent-based swaps frontend has to stop promising
Intent-based swaps hand execution to a solver, so your swap UI can no longer promise a price it does not control. The quote becomes a hope, failure looks different, and the pending state needs its own screen.
Rollback netcode in the browser: determinism is the hard part
Rollback netcode in the browser is not the hard part. Determinism is. Why your game desyncs, what breaks in JavaScript, and whether you even need rollback.
Adding x402 payments to an API: the HTTP 402 flow, minus the hype
x402 payments let software pay software over HTTP 402. What the flow really does, why it lands for agents and not people, and the production traps the demo skips.
Gasless transactions are not free: what a paymaster costs
Gasless onboarding removes the gas step users hate, but the paymaster still pays and can be drained. What breaks in production, and how I would sponsor gas on purpose instead of by default.
EIP-7702 changed what your frontend can assume about a wallet
A normal wallet address can now carry code and act like a smart account. Why the old EOA-versus-contract check breaks, how to detect a delegated account, and the new phishing surface it brings.
What breaks when you cancel a streaming LLM response
Hit stop on a chat UI and the tokens stop scrolling, but the model often keeps generating and billing. What actually breaks on cancel, and how I wire it right.
The one thing I still will not let an AI agent do: database migrations
AI agent database migrations look fine in a demo and go quiet-wrong on real data. The agent can write the migration. It does not get to run it in prod.
Why serverless keeps exhausting your Postgres connection pool
Serverless functions exhaust a Postgres connection pool because each instance opens its own. Why it happens under load, and how I fix it with a pooler and short transactions.
MCP or a direct API call? When I skip the tool server
MCP vs direct API for an AI agent: when the tool server earns its place, when a plain API call is less code and fewer failure modes, and the test I use.
Giving an AI agent on-chain data? Do not start with raw RPC
Wiring an AI agent straight to an RPC node looks fine in a demo and falls apart on real questions. Why I put an indexer between the agent and the chain.
Durable execution: how I make an AI agent survive a crash mid-run
Durable execution for AI agents lets a run resume from the last checkpoint after a crash instead of redoing unsafe work. How I set it up with a step log and idempotent tools.
WebGPU will not fix your slow browser game
WebGPU shipped in every browser, but it will not fix a slow browser game. The real bottlenecks are download size and the main thread, not raw GPU power.
Most multi-agent systems do not need to be multi-agent
Most multi-agent systems add coordination overhead before they add value. When one good agent wins, when multiple agents pay off, and how I decide.
SSE or WebSockets? How I actually pick for real-time features
SSE or WebSockets for real-time features: how I actually decide, from someone who shipped live price and trading screens. Direction of data beats raw power.
Idempotent tool calls: do this before you let an agent retry
When a tool call times out, an AI agent often runs it twice. How idempotent tool calls and a retry budget keep retries from corrupting real data.
Your MCP server is eating the context window
Why MCP servers quietly fill an agent's context window with bloated tool schemas and oversized results, and how I keep an agent's context lean and useful.
Context rot: why a bigger context window will not fix your agent
Context rot is why long-running AI agents get worse as the prompt fills up. Why bigger windows do not help, and how I budget context to keep an agent sharp.
Why your real-time UI lies after a websocket reconnect
What happens to a real-time UI when the websocket drops and reconnects: stale data, missed events, and the resync patterns that keep live numbers honest.
Indexing on-chain data without losing your mind
Notes from building indexers for a top-10 crypto and a DeFi exchange. When The Graph is the right call, when Subsquid earns its keep, and the traps that cost me weekends.
Where AI coding agents earn their keep, and where they do not
An honest take after the hype: the tasks agents genuinely speed up, the ones where they quietly add risk, and how I would use them on a team.
How subgraphs actually work, from someone who ships them
A working engineer's guide to how The Graph subgraphs actually work, from event handlers and the store to reorg safety and the gotchas docs skip.
Handling chain reorgs without corrupting your indexer
How to handle chain reorgs in an indexer without corrupting state: confirmations, rollbacks, idempotent writes, and the quiet failure modes to fear.
Subsquid vs The Graph in 2026: a practical comparison
Subsquid vs The Graph in 2026 from someone who ships both: sync speed, query flexibility, hosting, and how to actually pick the right indexer.
What building a cross-chain bridge taught me about trust
Lessons from building a cross-chain bridge: where trust really lives, finality and replay risks, and why the boring parts are what keep funds safe.
The token swap frontend pitfalls that cost real money
Token swap frontend pitfalls that cost users real money: slippage, stale quotes, approvals, decimals, and the trust details most swap UIs get wrong.
Event ordering on EVM is not what you think
EVM event ordering trips up almost every indexer. Here is how logs are actually ordered on chain and the sort key you need to get it right.
Modeling on-chain data so your queries do not melt
On-chain data modeling decides whether your queries fly or crawl. Practical schema patterns for indexers that stay fast as the chain grows.
RPC reliability for Web3 apps that cannot go down
Web3 RPC reliability is where most production outages actually start. Patterns for failover, retries and fallbacks that keep your dapp up.
How a DeFi DEX is actually put together
A practical look at DeFi DEX architecture: the contracts, the indexer, the frontend, and where the genuinely hard engineering really lives.
Building a gas-aware frontend users trust
A gas-aware frontend tells users what a transaction will cost before they sign. Practical patterns for estimates, failures and honest UX.
A sane team workflow for AI coding agents
A practical AI coding agents workflow for teams that keeps review standards high, avoids merge chaos, and actually ships faster instead of slower.
RAG that actually works in production
What it really takes to get RAG in production working: retrieval quality, chunking, evals, and the boring plumbing that separates a demo from a real system.
How to evaluate an LLM feature without fooling yourself
A grounded guide to evaluate an LLM feature honestly: build real test sets, define what good means, and avoid the demo-driven self-deception that ships bad features.
Using AI for code review without lowering the bar
How to use AI code review to catch more bugs without lowering your standards: where the machine helps, where it misleads, and who stays accountable.
Prompt patterns that hold up for engineers
Practical prompt patterns for engineering work that survive contact with real systems: structure, constraints, examples, and treating prompts like code you maintain.
Agent architecture basics, minus the hype
A grounded look at AI agent architecture: the loop, tools, memory, and the failure modes nobody warns you about before you ship one.
Securing AI generated code before it ships
Practical advice on securing AI generated code: the vulnerabilities models repeat, how to catch them in review, and what to automate before merge.
Keeping LLM costs from quietly wrecking your margins
Practical LLM cost control: where the money actually goes, how to cut spend without hurting quality, and the metrics worth watching.
When not to reach for an AI agent
Knowing when not to use AI is a senior skill. The tasks where an agent quietly adds risk and cost, and the simpler tools that beat it every time.
Using AI agents inside a messy legacy codebase
How to use an AI agent in a legacy codebase without making the mess worse: scoping, context, guardrails, and where it genuinely helps.
Go vs Node for backends in 2026, from someone who ships both
Go vs Node for backends in 2026 from an engineer who ships both. Where each one wins, where it bites you, and how I actually pick between them.
TypeScript patterns that scale past a small team
TypeScript patterns that hold up as a codebase and team grow. Practical typing habits, where types pay off, and the clever tricks I have learned to avoid.
Next.js performance, the parts that actually move the needle
Next.js performance advice that moves the needle. What to fix first, where the real cost lives, and the optimizations that quietly waste your time.
Stop guessing about React re-renders
A practical guide to React re-renders: what actually triggers them, when they matter, and how to measure instead of sprinkling memo everywhere and hoping.
Postgres indexing basics every full-stack dev should know
Postgres indexing basics every full-stack dev should know: how indexes work, when to add one, composite column order, and how to read a query plan.
API design that lasts longer than the next refactor
Practical API design that survives years of change. Versioning, naming, error shapes and the boring choices that keep clients from breaking on you.
GraphQL pitfalls I keep seeing in production
The GraphQL pitfalls that bite teams in production: N+1 queries, missing depth limits, cache confusion and schemas that grow into a swamp.
Background jobs and queues without the 3am pages
How to build background jobs and queues that do not page you at 3am: idempotency, retries with backoff, dead letters and visibility you can trust.
How to ship fast without shipping a mess
Shipping fast and keeping quality are not opposites. The habits that let me move quickly without leaving a mess for next quarter to clean up.
Taming tech debt on a team that has to keep shipping
A practical approach to taming tech debt when you cannot stop shipping. How to spot the debt that actually hurts and pay it down without a big rewrite.
What running game jams taught me about shipping software
Running game jams taught me more about shipping software than most retros. Here is what a 48-hour deadline reveals about scope, focus, and finishing.
Game feel: why juice matters more than features
Game feel and juice are why a simple game feels great while a feature-rich one feels dead. Here is how I think about juice and why it beats more features.
Three.js performance for the web, learned the hard way
Three.js performance on the web comes down to draw calls, the main thread, and memory. Here are the bottlenecks that actually tank your frame rate.
ECS explained without the academic fog
ECS, the entity component system pattern, explained in plain terms. What it is, why it beats deep inheritance, and when it is overkill for your game.
Godot vs Unity in 2026 for small teams
Godot vs Unity in 2026 for small teams and solo devs. An honest take on which engine fits, where each one wins, and how to actually decide.
The case for shipping small games
Shipping small games beats hoarding a giant unfinished one. A senior engineer on why tiny finished projects teach more and keep you sane.
Building a developer community that actually sticks
Building a developer community that lasts is mostly showing up and lowering the bar to contribute. Hard-won lessons from running a game-dev group.
What creative coding does for a serious engineering career
Creative coding and a serious engineering career are not opposites. Games and toy projects sharpen the exact skills that make you better at real work.
Prototyping games fast so you fail cheap
Prototyping games fast is about answering one fun question before you build anything real. A practical method for failing cheap and finding the fun early.
Scope cutting is the real side-project skill
Scope cutting on side projects is the skill that decides whether you ship or stall. How to cut hard, ship something real, and finish what you start.
How I think about landing a senior remote engineering role
How I approach a remote senior engineer job hunt: targeting, proof of work, and the signals that actually get a reply from real teams.
What makes an engineer portfolio actually convert
What turns an engineer portfolio from a digital business card into something that gets real replies. Fewer projects, sharper signals, honest writing.
Building in public as an engineer who wants better work
Building in public as an engineer is not branding theater. How sharing real work quietly creates better opportunities and sharper thinking.
Freelance vs full-time for senior engineers in 2026
Freelance vs full-time for senior engineers in 2026: the real tradeoffs around money, risk, and the kind of work you end up doing day to day.
What twelve years self-taught taught me about the craft
Lessons from a self-taught engineer after twelve years shipping real software: how to learn without a syllabus and why fundamentals still beat trends.
Senior technical interviews, from both sides of the table
A senior technical interview should test judgment, not trivia. Here is how I run one and how I show up for one, after years on both sides.
How I choose a tech stack without chasing hype
Choosing a tech stack is a bet on the next few years, not a fashion choice. Here is the practical framework I use to pick tools I will not regret.
Writing pull requests people actually enjoy reviewing
Better pull requests are smaller, well-described, and easy to say yes to. Here is how I write PRs that get reviewed fast and merged clean.
Estimating software work without lying to yourself
Estimating software work is hard because we estimate the happy path and forget everything else. Here is how I give honest, useful estimates.
How I learn a new technology fast
To learn a new technology fast, skip the tutorials and build something real. Here is the practical method I use to get productive in days.