// Topic
Go
Definition
Go coverage in this archive spans 37 posts from Nov 2016 to Jan 2026 and leans into practical engineering craft: interfaces, testing, and maintainable implementation details. The strongest adjacent threads are ai, llm, and architecture. Recurring title motifs include go, production, patterns, and ai.
Working claims
- The through-line is clarity first: simple designs that survive change beat clever abstractions.
- Early posts lean on go and production, while newer posts lean on ai and go as constraints shifted.
- This topic repeatedly intersects with ai, llm, and architecture, so design choices here rarely stand alone.
How to apply this
- Keep interfaces small, automate regressions early, and make operational assumptions explicit in code.
- Start with the newest post to calibrate current constraints, then backtrack to older entries for first principles.
- When boundary questions appear, cross-read ai and llm before committing implementation details.
Where teams get burned
- Abstracting before usage patterns are stable enough to justify indirection.
- Treating style consistency as optional until quality and velocity both degrade.
- Applying guidance from 2016 to 2026 without revisiting assumptions as context changed.
Suggested reading path
- Start here (current state): Building Reliable AI Agents in Go
- Then read (operating middle): AI Code Review: What It Actually Catches (And What It Misses)
- Finish with (foundational context): Why We Chose Go for Our Backend Services
Related posts
- Building Reliable AI Agents in Go
- Running AI Locally: A Practical Guide for Teams Who Care About Control
- Agent Patterns That Survive Production
- RAG Retrieval That Actually Works
- AI-Assisted Code Migration: What Actually Works
- How I Actually Test LLM Features
- Function Calling Patterns That Survive Production
- Building Voice AI That People Actually Use
References
37 posts
- Building Reliable AI Agents in 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.
Running AI Locally: A Practical Guide for Teams Who Care About Control
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.
Agent Patterns That Survive Production
Single-prompt agents break on real tasks. Plan-execute-replan, orchestrated specialists, structured memory, and explicit recovery -- in Go -- are what actually works.
RAG Retrieval That Actually Works
Most RAG failures are retrieval failures. Fixing them requires hybrid search, smarter chunking, query expansion, and reranking -- measured independently from generation.
AI-Assisted Code Migration: What Actually Works
I used LLMs to help migrate a 200K-line Go codebase. The mechanical parts went fast. Everything else was still hard.
How I Actually Test LLM Features
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 Patterns That Survive 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.
Building Voice AI That People Actually Use
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.
LLM Structured Output in Go: JSON Schema, Validation, Retries
How to get reliable JSON from LLMs in Go with schemas, validation, repair loops, and typed contracts.
LLM Prompt Caching in Go: Cut Costs Without Breaking Things
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.
Architecting AI-Native Applications (Without the Delusion)
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.
Stop Paying OpenAI to Test Your Prompts
Local LLMs are finally good enough for development. Use them for iteration, keep the API bills for production.
Two Weeks With the Assistants API: What I Like, What I Hate
I built three things with the Assistants API. One shipped, one got scrapped, and one taught me where the API's limits really are.
I Tracked My AI-Assisted Coding for Three Months. Here Are the Numbers.
After three months of tracking Copilot and GPT-4 usage across real projects, the productivity picture is messier than the marketing suggests.
LLM Security: A Field Guide for People Who Ship Things
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.
Agent Architecture Patterns That Actually Work in Production
Most agent demos are impressive. Most agent production systems are not. Here is what separates the two.
Embedding Models Compared: Retrieval Quality, Cost, and Latency
A practical embedding model comparison for retrieval quality, vector size, latency, cost, and self-hosting tradeoffs.
Building Semantic Search in Go: From Embeddings to Production
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.
AI Code Review: What It Actually Catches (And What It Misses)
After three months of using AI-assisted code review across multiple projects, here's what actually works and what's just noise.
RAG Patterns That Actually Work in Production
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.
Vector Databases: What They Actually Are and When You Need One
A practical guide to vector databases -- what they store, how similarity search works, and the architectural decisions that matter in production.
LLM Integration Patterns That Actually Survive Production
Practical patterns for integrating LLMs into real applications -- prompt management, structured outputs, caching, fallbacks, and tool use -- with Go examples.
Testing Microservices Without Losing Your Mind
Microservices fail at the seams. A layered test strategy that keeps feedback fast and catches integration issues before production.
Caching: The Easy Part Is Adding It, the Hard Part Is Everything Else
Cache-aside, write-through, invalidation strategies, and the failure modes that will wake you up at night. With Go examples.
Rate Limiting: The Boring Feature That Saves You at 3 AM
Rate limiting algorithms, implementation tradeoffs, and practical lessons from building limiters for high-traffic APIs at a real-time messaging company.
Distributed Systems Patterns I Keep Reaching For
The patterns that actually survive production across failure handling, consistency, messaging, coordination, and scaling.
Rust for Cloud Services: A Go Developer's Honest Take
I write Go for a living. Rust is not replacing it. But I have to be honest about where Rust wins.
API Gateways: Build, Buy, or Regret
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.
gRPC Patterns That Actually Work in Production
Hard-won gRPC patterns from building Decloud's service mesh. Proto design, Go implementation, error handling, and the mistakes that cost us weekends.
Wasm Outside the Browser: Real Promise, Real Gaps
WebAssembly outside the browser is genuinely interesting for edge, plugins, and sandboxing. But the tooling gaps are bigger than the hype admits.
Your Load Tests Are Lying to You
Most load tests produce comforting numbers instead of useful answers. Here's what I learned the hard way about getting honest results.
Your Monolith Is Probably Fine
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.
Your API Is a Contract You Can't Take Back
Hard-won lessons on designing HTTP APIs that survive real integrations, drawn from building fintech and mobility platforms.
GitOps: Stop SSHing Into Production
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.
Making Go Services Fast: What Actually Matters
Practical patterns for squeezing performance out of Go services — profiling, allocation control, bounded concurrency, and HTTP/DB tuning from real production work.
A Go Developer Looks at Rust for Backend 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.
Why We Chose Go for Our Backend Services
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.