Every post
All Posts
The full archive, newest first.
Don't Let One Agent Grade Its Own Homework
The same reasoning that produces a mistake explains it away just as convincingly on the second pass. Here's when a second, adversarial agent is worth the extra inference cost — and when it isn't.
Hermes Agent: An AI That Lives on Your Machine
Nous Research's Hermes Agent isn't a chatbot or an IDE copilot — it's a self-hosted daemon with persistent memory that writes its own skills and gets smarter every day.
How the Model Context Protocol Became the Default Way Agents Talk to Tools
MCP went from an Anthropic proposal to a cross-vendor standard in barely a year. Here is what the Model Context Protocol actually is, and why it matters if you build agents.
Beyond the Syntax: The Most Surprising Realities of the 2026 "Vibe Coding" Revolution
Syntax is now a commodity and intent is the only moat. Five surprising realities of agentic engineering in 2026 - from why the harness beats the model to the 19% verification tax.
Half-Year Check-In: What Actually Changed in AI Engineering in H1 2026
Six months into 2026, the hype has settled enough to see what really shifted. A grounded look at what changed, what did not, and what it means for the second half of the year.
Agent Skills: Packaging Procedural Knowledge for Reuse
Prompts capture intent; skills capture know-how. Agent Skills are portable packages of procedural knowledge that let an agent do a task the way your team actually does it.
The New Senior Engineer: Judgment, Architecture, and Taste in an AI World
If agents write much of the code, what makes someone senior? The answer is the part that never automated: judgment, architecture, and taste. Here is what the role becomes.
Ethics and Accountability When Agents Ship Code
When an agent writes code that fails, who is responsible? As agents take on more of the work, accountability, bias, and transparency become engineering concerns, not afterthoughts.
From Prototype to Production: Hardening an AI Feature for Real Users
The AI demo took an afternoon. Making it safe, reliable, and affordable for real users is the other 90%. Here is the checklist that turns a prototype into something you can ship.
Evals as a First-Class Artifact: Building a Regression Suite for Your Prompts
You would not ship code without tests. Shipping prompts and agents without evals is the same gamble. Here is how to build an eval suite that catches regressions before users do.
Observability for Agents: Tracing Non-Deterministic Systems
When an agent does something wrong, "it ran" is not enough — you need to see what it thought, called, and decided. Here is how observability adapts to non-deterministic systems.
Cost Engineering for LLM Apps: Token Budgets, Caching, and Routing
An LLM feature that works in a demo can be ruinous at scale. Cost engineering is the discipline of keeping quality high while keeping the bill sane. Here are the levers that matter.
The Orchestrator's Toolkit: Running Async Agents and Reviewing Their PRs
The most leveraged engineers in 2026 work in two modes: conducting an agent in real time, and orchestrating many agents asynchronously. Here is what the orchestrator mode looks like in practice.
Multi-Agent Systems: Orchestrating Specialists Without Chaos
One agent doing everything hits a ceiling. Multiple specialized agents can go further, or collapse into expensive chaos. Here is what separates orchestration from a mess.
Designing APIs for Agents, Not Just Humans
Agents are becoming primary consumers of your APIs. They read schemas, not docs, and they fail differently than human developers. Here is how to design an interface an agent can use well.
Typed End to End: TypeScript Patterns for AI-Era Codebases
When agents write much of your code, types stop being optional ergonomics and become the guardrail that catches what review misses. Here are the TypeScript patterns that matter most.
Next.js 16 Cache Components: A New Mental Model for Caching
Next.js 16 introduces Cache Components, built on Partial Pre-Rendering and an explicit use cache. It replaces years of confusing implicit caching with something you can reason about.
Securing the Agent Surface: Prompt Injection, Tool Abuse, and the New Threat Model
Give an agent tools and autonomy and you have created a new attack surface. Prompt injection turns untrusted text into commands. Here is the threat model and the defenses.
Testing AI-Generated Code: Property-Based and Mutation Testing in an Agentic Workflow
When an agent writes both the code and the tests, who tests the tests? Property-based and mutation testing give you confidence that does not depend on the agent being right.
Code Review When the Author Is an Agent
Reviewing agent-written code is not the same as reviewing a colleague. Agents fail differently, never push back, and produce volume. Here is how review has to adapt.
The 19% Verification Tax: The Real Cost of AI-Generated Code
A study found experienced developers were 19% slower on some tasks using AI assistants. Far from anti-AI, it is the most useful number for building a sane workflow. Here is why.
Knowledge Graphs Meet LLMs: Grounding Agents in Structured Truth
Vector search is fuzzy; knowledge graphs are precise. Combining them gives agents both recall and exactness. Here is how structured knowledge anchors LLMs to facts.
RAG in 2026: From Naive Retrieval to Agentic Search
Basic retrieval-augmented generation — embed, search, stuff the context — only gets you so far. Here is how RAG has matured into something an agent actively drives.
Self-Hosting Open-Weight Models: When It Pays Off and When It Does Not
Open-weight models let you run inference on your own infrastructure. That buys control and privacy, but it is not free. Here is an honest framework for deciding.
Small Language Models Are Eating the Routine Work
The headlines go to frontier models, but cheap, fast small models are quietly absorbing most production traffic. Here is why smaller is winning the high-volume jobs.
Guardrails and Hooks: Deterministic Safety for Non-Deterministic Agents
You cannot make an agent perfectly reliable, but you can make certain mistakes impossible. Guardrails and hooks are the deterministic layer that catches what the model gets wrong.
Agent Memory: Giving Your AI Tools a Past
A stateless agent starts every task from a blank slate. Memory is what lets it carry context across steps, sessions, and projects. Here are the patterns that actually work.
Building Your First MCP Server: A Hands-On Walkthrough
The Model Context Protocol is the standard way to give agents tools. This walkthrough builds a working MCP server from scratch and explains each decision along the way.
Context Engineering 101: Designing What Your Agent Knows
Prompt engineering is about phrasing. Context engineering is about what information the model has when it answers. Here is how to design context deliberately for reliable agents.
Eight Predictions for AI-Assisted Software Engineering in 2026
Eight grounded predictions for how AI changes software engineering in 2026 — from agent verification to model routing to what a senior engineer actually does all day.
2025 in Review: The Year Software Engineering Became Agentic
From autocomplete to autonomous agents, from prompts to harnesses, from one model to a weekly frontier. A look back at the year that reshaped how software gets built.
MCP Joins the Linux Foundation: Why Vendor-Neutral Governance Matters
In December 2025, Anthropic donated the Model Context Protocol to a Linux Foundation fund co-founded with Block and OpenAI. Here is why that governance move matters more than any feature.
The 25-Day Model Blitz: Making Sense of the Late-2025 Release Storm
In under a month, Grok 4.1, Gemini 3, Claude Opus 4.5, and GPT-5.2 all landed. Here is a calm read on what the release storm actually means for people who build software.
NotebookLM Infographics: Transform Your Knowledge into Stunning Visuals
NotebookLM now creates production-ready infographics with NanoBanana Pro, turning complex technical sources into visual summaries instantly—plus new features for source discovery and customization.
Intelligent Model Routing: Using Frontier and Small Models Together
Running every request through your most expensive model is the easiest way to burn your AI budget. Model routing sends each task to the cheapest model that can handle it.
Claude Opus 4.5 and the Rise of Computer-Use Agents
Claude Opus 4.5 posted state-of-the-art results on OSWorld, a benchmark for operating a real computer. Here is why computer-use is a turning point for what agents can automate.
Gemini 3 and the Multimodal Turn: What Native Reasoning Across Media Unlocks
Gemini 3 reasons across text, images, audio, and video together. Beyond the benchmarks, here is what genuinely native multimodality changes for the things developers build.
Choosing a Model in 2026: A Task-to-Model Framework
With a new frontier model every few weeks, picking one is now a recurring decision. Here is a practical framework for matching the right model to each task instead of chasing leaderboards.
Evaluating LLMs Like an Engineer: Benchmarks vs. Reality
OSWorld, GPQA, SWE-bench — leaderboard numbers are everywhere. Here is how to read them like an engineer and build evals that predict performance on your actual work.
Spec-Driven Development: Writing Specs an Agent Can Build From
As agents take on more implementation, the spec becomes the source code. Here is how to write specifications precise enough for an agent to execute and a human to verify.
From Autocomplete to Autonomy: The Anatomy of a Modern Coding Agent
A year ago AI meant autocomplete. Now agents plan, edit, run, and verify across many steps. Here is what is actually inside one and why the loop matters more than the model.
A Mental Model for the React and Next.js Server-Client Boundary
Server Components confuse people because the boundary is invisible. Here is a mental model that makes "where does this code run?" obvious every time.
Stop Hand-Optimizing Renders: Living With the React Compiler
The React Compiler changes your day-to-day habits, not just your build output. Here is how to unlearn manual memoization and what to watch for as you migrate.
React 19.2 Is Here: What the React Compiler Actually Changes
React 19.2 ships the React Compiler as a first-class part of the toolchain. Here is what it automates, what it means for your code, and where it still needs your help.
Building QRClx.com: An AI Co-Creator Experiment
Discover how I built a modern URL shortener with QR code generation using AI as a true development partner. Learn about the technology stack, challenges, and lessons from this collaborative human-AI development experiment.
The Rise of AI DevOps: Automating CI/CD and Infrastructure with Intelligence
How AI augments pipelines to predict failures, optimize resources, and auto-heal deployments.
The Future of Software Careers in the Age of AI
Roles, skills, and strategies to thrive as AI reshapes the developer job market.
Prompt Engineering for Developers: Writing Code with Words
How to craft prompts that yield accurate, efficient code and documentation across languages and stacks.
Knowledge Graphs for Developers: Turning Data into Context
Build AI-driven maps that connect code, docs, and business logic for faster discovery and onboarding.
The Future of Web Development: What's Coming in 2026 and Beyond
Exploring the latest trends and technologies shaping the future of web development, from AI-native applications to next-generation frameworks.
From Legacy to Intelligent Systems: How AI Is Modernizing Software Development
Practical strategies for transforming legacy systems with AI-assisted refactoring, UX upgrades, and maintainability boosts.
Ethics in AI Development: What Every Software Engineer Should Know
A practical playbook for bias mitigation, privacy, transparency, and responsible shipping.
Building AI-Enhanced Web Apps: From React to Next.js with Cognitive Services
Patterns for integrating vision, search, and NLP into modern web apps with React/Next.js.
AI-Powered Testing: Smarter Unit Tests and Bug Detection
Using AI to generate tests, surface edge cases, and analyze logs to catch bugs early.
AI Pair Programming: Is GitHub Copilot the Future of Development?
A field guide to using AI coding assistants effectively - benefits, risks, and best practices.
AI-Driven Resume Analysis for Developers: Beating the Bots
Make your developer CV readable by ATS and AI - without losing the human story.
SOLID in TypeScript: Practical Patterns with Concise Examples
Master the five SOLID principles with practical TypeScript examples. Learn how to write maintainable, extensible, and testable code using Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion principles.
AI RAG: Revolutionizing Information Retrieval with Context-Aware AI
Explore how Retrieval Augmented Generation (RAG) is transforming AI applications by combining the power of large language models with real-time information retrieval.
Agentic Workflows: The Future of AI-Powered Automation
Discover how agentic AI systems are revolutionizing workflows by enabling autonomous decision-making and complex task orchestration across multiple domains.
AI Code Generation: Revolutionizing Developer Productivity
Explore how AI-powered code generation tools are transforming software development, from GitHub Copilot to specialized code agents, and their impact on developer workflows.
Web Components: Building the Future of Frontend Architecture
Explore how Web Components are revolutionizing frontend development by providing framework-agnostic, reusable building blocks for modern web applications.
Building Scalable React Applications
Best practices and patterns for creating maintainable React applications that can grow with your team and user base.
The Art of Code Review: A Developer's Guide
How to give and receive constructive code reviews that improve both code quality and team collaboration.
TypeScript Tips for Better Developer Experience
Advanced TypeScript techniques and configurations that will make your development workflow smoother and more productive.