// Topics / Go

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

References

37 entries tagged “Go”

    Building Reliable AI Agents in Go · 6 min 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. agents reliability ai Running AI Locally: A Practical Guide for Teams Who Care About Control · 6 min 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. local-ai development ollama Agent Patterns That Survive Production · 7 min Single-prompt agents break on real tasks. Plan-execute-replan, orchestrated specialists, structured memory, and explicit recovery -- in Go -- are what actually works. agents ai go RAG Retrieval That Actually Works · 7 min Most RAG failures are retrieval failures. Fixing them requires hybrid search, smarter chunking, query expansion, and reranking -- measured independently from generation. rag retrieval vector-search AI-Assisted Code Migration: What Actually Works · 4 min I used LLMs to help migrate a 200K-line Go codebase. The mechanical parts went fast. Everything else was still hard. ai code-migration refactoring How I Actually Test LLM Features · 6 min 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. llm testing ai Function Calling Patterns That Survive Production · 7 min 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. function-calling llm ai Building Voice AI That People Actually Use · 5 min 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. voice ai audio LLM Structured Output in Go: JSON Schema, Validation, Retries · 7 min How to get reliable JSON from LLMs in Go with schemas, validation, repair loops, and typed contracts. llm structured-output json LLM Prompt Caching in Go: Cut Costs Without Breaking Things · 6 min 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. llm caching go Architecting AI-Native Applications (Without the Delusion) · 7 min 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. architecture ai design Stop Paying OpenAI to Test Your Prompts · 4 min Local LLMs are finally good enough for development. Use them for iteration, keep the API bills for production. llm local-development ollama Two Weeks With the Assistants API: What I Like, What I Hate · 4 min I built three things with the Assistants API. One shipped, one got scrapped, and one taught me where the API's limits really are. openai assistants-api ai I Tracked My AI-Assisted Coding for Three Months. Here Are the Numbers. · 5 min After three months of tracking Copilot and GPT-4 usage across real projects, the productivity picture is messier than the marketing suggests. ai developer-tools productivity LLM Security: A Field Guide for People Who Ship Things · 6 min 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. security llm ai Agent Architecture Patterns That Actually Work in Production · 6 min Most agent demos are impressive. Most agent production systems are not. Here is what separates the two. ai agents llm Embedding Models Compared: Retrieval Quality, Cost, and Latency · 6 min A practical embedding model comparison for retrieval quality, vector size, latency, cost, and self-hosting tradeoffs. embeddings ai go Building Semantic Search in Go: From Embeddings to Production · 7 min 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. search ai embeddings AI Code Review: What It Actually Catches (And What It Misses) · 4 min After three months of using AI-assisted code review across multiple projects, here's what actually works and what's just noise. ai code-review developer-tools RAG Patterns That Actually Work in Production · 8 min 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. rag ai llm Vector Databases: What They Actually Are and When You Need One · 6 min A practical guide to vector databases -- what they store, how similarity search works, and the architectural decisions that matter in production. vector-database ai embeddings LLM Integration Patterns That Actually Survive Production · 6 min Practical patterns for integrating LLMs into real applications -- prompt management, structured outputs, caching, fallbacks, and tool use -- with Go examples. ai llm go Testing Microservices Without Losing Your Mind · 5 min Microservices fail at the seams. A layered test strategy that keeps feedback fast and catches integration issues before production. testing microservices contract-testing Caching: The Easy Part Is Adding It, the Hard Part Is Everything Else · 6 min Cache-aside, write-through, invalidation strategies, and the failure modes that will wake you up at night. With Go examples. caching redis performance Rate Limiting: The Boring Feature That Saves You at 3 AM · 4 min Rate limiting algorithms, implementation tradeoffs, and practical lessons from building limiters for high-traffic APIs at a real-time messaging company. rate-limiting api backend Distributed Systems Patterns I Keep Reaching For · 6 min The patterns that actually survive production across failure handling, consistency, messaging, coordination, and scaling. distributed-systems architecture patterns Rust for Cloud Services: A Go Developer's Honest Take · 4 min I write Go for a living. Rust is not replacing it. But I have to be honest about where Rust wins. rust go cloud API Gateways: Build, Buy, or Regret · 6 min 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. api-gateway go kong gRPC Patterns That Actually Work in Production · 11 min Hard-won gRPC patterns from building Decloud's service mesh. Proto design, Go implementation, error handling, and the mistakes that cost us weekends. grpc go microservices Wasm Outside the Browser: Real Promise, Real Gaps · 3 min WebAssembly outside the browser is genuinely interesting for edge, plugins, and sandboxing. But the tooling gaps are bigger than the hype admits. webassembly wasm edge Your Load Tests Are Lying to You · 3 min Most load tests produce comforting numbers instead of useful answers. Here's what I learned the hard way about getting honest results. testing performance reliability Your Monolith Is Probably Fine · 5 min 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. microservices architecture monolith Your API Is a Contract You Can't Take Back · 4 min Hard-won lessons on designing HTTP APIs that survive real integrations, drawn from building fintech and mobility platforms. api design rest GitOps: Stop SSHing Into Production · 9 min 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. gitops devops kubernetes Making Go Services Fast: What Actually Matters · 7 min Practical patterns for squeezing performance out of Go services — profiling, allocation control, bounded concurrency, and HTTP/DB tuning from real production work. go performance backend A Go Developer Looks at Rust for Backend Work · 4 min 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. rust go backend Why We Chose Go for Our Backend Services · 5 min 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. golang go backend
All topics →