Blog
Thoughts on AI Agents, Agentic AI, Frontend Engineering, Web3, and building the future of software.
Agentic Payments: How AI Agents Are Learning to Spend Money Onchain
Machine-to-machine commerce is here — agents paying for APIs, compute, and services with onchain rails. How payment protocols, spending policies, and settlement actually work in practice.
Shipping Agents Under the EU AI Act: A Builder's Compliance Checklist
High-risk obligations land in August 2026 with penalties up to 7% of global turnover. The practical checklist I use to keep agentic features shippable without a legal team on standby.
Choosing an Agent Framework in 2026: LangGraph vs CrewAI vs Roll-Your-Own
A field comparison of the frameworks I've actually shipped on — explicit graphs vs role-based crews vs hand-rolled loops — and how to tell which one your project really needs.
Prompt Injection Is the New SQL Injection: Securing AI Agents in Production
Prompt injection still drives most agentic security failures. The runtime guardrail layer I put between users, models, and tools — and the data-exfiltration paths teams keep missing.
Small Language Models Are Eating Your Agent: A Heterogeneous Routing Playbook
Fine-tuned 7B models now handle most routine agent steps cheaper and more reliably than frontier models. How I route work across SLMs and big models — and the 90% cost cut that follows.
Context Engineering: Why Curating Context Beats Crafting the Perfect Prompt
The bottleneck moved from prompt wording to context quality. How I decide what actually goes into the window — retrieval, compaction, and the noise that quietly wrecks agent decisions.
Building an Internal AI Platform: What I Wish I'd Known Before Year One
A year of building the AI platform other teams build on top of — the abstractions that paid off, the ones that didn't, and the governance work nobody warned me about.
Production Prompt Engineering: Versioning, A/B Testing, and Rollbacks
Treating prompts like code: how I version, test, and roll back prompt changes the same way I would a database migration — and the tooling that makes it boring.
The 10x Engineer Is Now a Team: How AI Changes What 'Senior' Means
Senior used to mean writing the hardest code. In 2026 it means orchestrating agents, reviewing their output, and knowing which problems still need a human first-principles pass.
Reviewing AI-Generated Code: A Practical Framework for Senior Engineers
What I look for first in a Claude- or Copilot-generated PR — the failure modes that hide in plausible-looking code, and how my review checklist has changed.
ZK + AI: Proving Inference Without Revealing the Model
Zero-knowledge proofs of inference are finally tractable for small models. Here's what zkML actually delivers in 2026 — and where it's still a research project.
On-Chain Agents: When Smart Contracts Call LLMs (and Vice Versa)
Bridging deterministic contracts and non-deterministic models — oracle patterns, intent settlement, and the failure modes nobody warns you about.
TypeScript at Scale: Patterns That Survive a 500-File Codebase
The TypeScript patterns I keep reaching for in large codebases — branded types, exhaustive switches, module boundaries — and the clever tricks I've learned to stop using.
Edge-Rendered AI: Cloudflare Workers + Open Models for Sub-100ms Responses
Pushing inference to the edge with Workers AI and Llama-class models — what works, what doesn't, and where you still need a real GPU somewhere upstream.
Streaming UI: Building Responsive Interfaces on Top of LLM Token Streams
From SSE to React Suspense — how I build chat and agent UIs that feel instant, handle interruption gracefully, and don't fall apart when the network does.
The Economics of Inference: Routing, Caching, and Batching for LLM Apps
A practical playbook for cutting per-request cost without sacrificing latency — model routing, semantic cache hit rates, request batching, and the metrics that actually matter.
Long-Running Agents: State, Recovery, and Resumability Beyond a Single Turn
What it takes to run an agent for hours instead of seconds: durable state, checkpointing, idempotent tools, and recovering cleanly when the model — or the host — dies mid-task.
Evaluating AI Agents: Building Test Suites for Non-Deterministic Systems
Why traditional unit tests fall apart on agents, and the eval harness I actually use in production — golden traces, rubric grading, and regression catching.
React 19 in Production: Server Actions, use(), and the End of useEffect Hell
What actually changed when React 19 hit production — the patterns that replace useEffect, and the migration mistakes I made so you don't have to.
AI Cost Engineering: Cutting Your LLM Bill by 80% Without Sacrificing Quality
Prompt caching, model routing, batch APIs, and structured outputs — the practical playbook that turned a six-figure inference bill into a five-figure one.
Account Abstraction Meets AI: Smart Wallets That Think for Themselves
Combining ERC-4337 smart accounts with AI agents to build wallets that auto-pay subscriptions, rebalance portfolios, and enforce spending policies.
Agent Observability: Tracing, Evaluating, and Debugging Multi-Step AI Workflows
The new ops stack for AI — how to trace agent runs, build eval harnesses, and catch silent regressions before your users do.
WebGPU and On-Device LLMs: Running AI in the Browser Without a Backend
How WebGPU plus quantized open models lets you ship private, offline-capable AI features straight to the browser — with real benchmarks.
Voice AI Agents: Building Real-Time Conversational Experiences in 2026
Architecture, latency tricks, and turn-taking patterns for production-grade voice agents — from telephony to in-browser real-time APIs.
Spec-Driven Development: How AI Coding Agents Are Reshaping the SDLC
Vibe coding is fading — specs are back. How writing precise specs (not prompts) gets the most out of Claude Code, Cursor, and Copilot Workspace.
Reasoning Models in Production: When Extended Thinking Is Worth the Cost
A field guide to deciding when to invoke reasoning models, how to budget thinking tokens, and patterns that justify the latency tradeoff.
Computer Use Agents: Teaching AI to Click, Type, and Browse Like a Human
How modern AI agents control real desktops and browsers — building reliable computer-use workflows with screenshot grounding and action loops.
Model Context Protocol (MCP): Building Universal Tool Integrations for AI Agents
A practical guide to MCP — the open standard letting any AI agent talk to any tool, database, or service through a single protocol.
10 Lessons from 10 Years of Software Engineering
Hard-won lessons from a decade of building software — from code quality to team dynamics to knowing when to ship.
React Server Components + AI: The Perfect Match
How React Server Components enable new AI-powered patterns — server-side AI inference, streaming AI responses, and smart caching.
Agentic RAG: When Your AI Agent Decides What to Retrieve
Moving beyond static RAG pipelines to agentic retrieval where the AI decides what information it needs and how to get it.
Building a CI/CD Pipeline with AI-Powered Testing
Integrate AI agents into your CI/CD pipeline to auto-generate tests, detect flaky tests, and provide intelligent failure analysis.
Smart Contract Security: How AI Agents Can Catch Vulnerabilities
Using AI agents to automatically audit smart contracts for common vulnerabilities like reentrancy, overflow, and access control issues.
AI Agent Memory: Short-Term, Long-Term, and Episodic
Understanding the different types of memory in AI agents and how to implement them for better context retention.
Tailwind CSS + shadcn/ui: Building a Design System That Scales
How to build a consistent, maintainable design system using Tailwind CSS and shadcn/ui components in a Next.js project.
LLM Tool Use Patterns: Giving AI Agents Superpowers
Deep dive into how AI agents use tools — designing tool schemas, handling errors, and chaining tool calls for complex workflows.
From Senior Engineer to AI-Augmented Engineer: A Career Guide
How to evolve your engineering career by mastering AI tools — from prompt engineering to agent orchestration.
Building Autonomous DeFi Agents with Ethers.js and AI
Create an AI agent that monitors DeFi protocols, analyzes opportunities, and executes transactions autonomously.
The Future of Frontend: AI-Native UI Components
Exploring UI components that adapt to users in real-time using AI — personalized layouts, smart forms, and predictive interfaces.
AI-Powered Code Review: Building an Automated PR Reviewer
Build an AI agent that reviews pull requests, catches bugs, suggests improvements, and enforces coding standards.
Next.js 15 App Router: Advanced Patterns for Production Apps
Advanced patterns including parallel routes, intercepting routes, and streaming that make Next.js 15 apps blazing fast.
RAG vs Fine-Tuning: When to Use What for Your AI Application
A practical comparison of retrieval-augmented generation and fine-tuning approaches for building AI-powered applications.
Building Your First AI Agent with Claude Agent SDK
Step-by-step guide to building a functional AI agent that can browse the web, write code, and complete tasks autonomously.
Multi-Agent Systems: Orchestrating AI Teams for Complex Tasks
How to design systems where multiple AI agents collaborate - planner, coder, reviewer, and tester working in concert.
The Rise of AI Agents: How Autonomous Systems Are Reshaping Software Development
AI agents are no longer science fiction. From code generation to autonomous debugging, discover how AI agents are transforming how we build software in 2025 and beyond.
Agentic AI Design Patterns Every Developer Should Know
From ReAct to multi-agent orchestration, explore the key design patterns powering the next generation of AI-driven applications.
Building Modern React Apps in 2026: What's Changed and What Matters
React 19, Server Components, and the evolving ecosystem - a practical guide to building React applications that are fast, maintainable, and future-proof.
When Web3 Meets AI Agents: The Future of Decentralized Autonomous Systems
Exploring the powerful intersection of blockchain technology and AI agents - from autonomous trading to decentralized AI governance.