Go

Reliable agents aren't prompted into existence. They're engineered -- with bounded tools, validation at every step, explicit recovery paths, and the same discipline you'd apply to any production system. Here's how I build them in Go.

Local AI is no longer a hobby project. Here's how to set it up properly: provider abstraction, versioned models, evaluation harnesses, and cloud fallback for when local isn't enough.

Single-prompt agents break on real tasks. Plan-execute-replan, orchestrated specialists, structured memory, and explicit recovery -- in Go -- are what actually works.

Most RAG failures are retrieval failures. Fixing them requires hybrid search, smarter chunking, query expansion, and reranking -- measured independently from generation.

I used LLMs to help migrate a 200K-line Go codebase. The mechanical parts went fast. Everything else was still hard.

LLM outputs are non-deterministic. That doesn't mean you can't test them rigorously. Here's the layered testing approach I use in production.

Function calling is how LLMs touch real systems. Treat tools like APIs, arguments like untrusted input, and permissions like the model is an intern with root access.

Voice AI is ready to ship. The hard parts are latency, interruptions, and knowing when voice is the wrong interface. Here's how I approach it.

LLMs generate text, not data structures. Here are the patterns I use in Go to get reliable, validated JSON out of models -- with schemas, retries, and repair loops.

Caching LLM responses is the highest-leverage optimization most teams are not doing. Here is how I implement it in Go, with real patterns for keys, invalidation, and safety.

The architecture of an AI-native app is fundamentally different from bolting a model onto a CRUD app. Here is how I structure them -- with code, layers, and hard-won opinions.

Local LLMs are finally good enough for development. Use them for iteration, keep the API bills for production.

I built three things with the Assistants API. One shipped, one got scrapped, and one taught me where the API's limits really are.

After three months of tracking Copilot and GPT-4 usage across real projects, the productivity picture is messier than the marketing suggests.

LLMs introduce security failure modes that most teams are not defending against. Prompt injection, data leakage, tool abuse, and cost attacks are real and exploitable today.

Most agent demos are impressive. Most agent production systems are not. Here is what separates the two.

I benchmarked five embedding models against the same retrieval task. The results challenged some of my assumptions about model size, cost, and quality.

A hands-on walkthrough of building semantic search with Go, OpenAI embeddings, and pgvector. Includes chunking strategies, hybrid retrieval, and the gotchas I hit along the way.

After three months of using AI-assisted code review across multiple projects, here's what actually works and what's just noise.

RAG is the default architecture for grounding LLMs in private data. Here are the patterns that survive real traffic, with Go examples from production systems.

A practical guide to vector databases -- what they store, how similarity search works, and the architectural decisions that matter in production.

Practical patterns for integrating LLMs into real applications -- prompt management, structured outputs, caching, fallbacks, and tool use -- with Go examples.

Microservices fail at the seams. A layered test strategy that keeps feedback fast and catches integration issues before production.

Cache-aside, write-through, invalidation strategies, and the failure modes that will wake you up at night. With Go examples.

Rate limiting algorithms, implementation tradeoffs, and practical lessons from building limiters for high-traffic APIs at a real-time messaging company.

The patterns that actually survive production across failure handling, consistency, messaging, coordination, and scaling.

I write Go for a living. Rust is not replacing it. But I have to be honest about where Rust wins.

I've built a custom Go gateway, run Kong in prod, evaluated Envoy, and used managed cloud gateways. Here's what I actually recommend after doing all of them wrong at least once.

Hard-won gRPC patterns from building Decloud's service mesh. Proto design, Go implementation, error handling, and the mistakes that cost us weekends.

WebAssembly outside the browser is genuinely interesting for edge, plugins, and sandboxing. But the tooling gaps are bigger than the hype admits.

Most load tests produce comforting numbers instead of useful answers. Here's what I learned the hard way about getting honest results.

Most teams shouldn't be migrating to microservices. Here's how to tell if you actually should, and how to do it without wrecking your delivery for eighteen months.

Hard-won lessons on designing HTTP APIs that survive real integrations, drawn from building fintech and mobility platforms.

How I moved three teams off ad-hoc kubectl deployments and onto Git-driven infrastructure -- with code examples, repo layouts, and the mistakes I made along the way.

Practical patterns for squeezing performance out of Go services — profiling, allocation control, bounded concurrency, and HTTP/DB tuning from real production work.

I write Go every day at the fintech startup. Here's why I've been spending evenings with Rust, what impressed me, and where it still hurts.

How Go became the default backend language at Dropbyke and a fintech startup, what it replaced, and the honest tradeoffs we accepted along the way.