// 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

53 entries tagged “Go”

    Building Reliable AI Agents in Go · 6 min Reliable agents are engineered, not prompted: bounded tools, validation at every step, explicit recovery paths. 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. How to set it up properly: provider abstraction, versioned models, eval harnesses, and a cloud fallback. local-ai development ollama Testing AI Where It Actually Runs · 6 min Offline evals are necessary but not sufficient. Here's how I test AI features in production with shadow mode, canaries, and rollback automation -- with Go code. testing ai production MCP in Practice: Building Tool Servers in Go · 7 min Model Context Protocol promises to standardize how AI talks to tools. I built an MCP server in Go to see if the promise holds up. Here's what I found. mcp ai go AI Code Review Is Mostly Noise · 4 min I've been running AI code review on real PRs for months. It catches some real bugs. It also generates a staggering amount of useless commentary. code-review ai development Reasoning Models in Production: A Practical Guide · 7 min Reasoning models are powerful but expensive and slow. Here's how I integrate them in Go services with routing, async patterns, and cost controls that actually work. reasoning o1 llm Agent Patterns That Survive Production · 7 min Single-prompt agents break on real tasks. Plan-execute-replan, orchestrated specialists, structured memory, and explicit recovery are what survive -- in Go. agents ai go RAG Retrieval That Actually Works · 7 min Most RAG failures are retrieval failures. Hybrid search, smarter chunking, query expansion, and reranking -- measured separately 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 skip. How I implement it in Go -- keys, invalidation, and safety patterns. llm caching go Architecting AI-Native Applications (Without the Delusion) · 7 min AI-native apps are fundamentally different from a model bolted onto a CRUD app. 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 bring security failure modes most teams aren't defending against. Prompt injection, data leakage, tool abuse, and cost attacks are 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 -- chunking, hybrid retrieval, and the gotchas I hit. ai embeddings go 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 Go Concurrency Patterns I Use in Every Service · 7 min Worker pools, fan-out/fan-in, pipelines, and the cancellation discipline that keeps Go services predictable under load. go concurrency patterns 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 TypeScript: A Go Developer's Honest Take · 4 min TypeScript is the best thing to happen to JavaScript. That bar is lower than people think. Here's what actually matters for large codebases. typescript javascript best-practices OpenTelemetry in Late 2021: What's Ready and What's Not · 5 min Tracing is ready. Metrics are getting there. Logs are not. Here's a practical adoption path and the code to back it up. opentelemetry observability tracing Event Sourcing in Practice: What I Learned Building Financial Event Pipelines · 7 min Event sourcing is powerful but expensive to get wrong. Here's what actually works, with Go code, drawn from building event pipelines at the fintech startup. event-sourcing architecture cqrs Feature Flags at Scale: What Nobody Warns You About · 5 min Feature flags are great until you have 847 of them and nobody knows which ones are safe to remove. Practical lessons from Decloud and enterprise teams. feature-flags deployment devops WebAssembly Beyond the Browser: A 2021 Progress Report · 5 min Sixteen months after my first Wasm post, here's what's actually moved. WASI is still early, but edge computing and plugin systems are turning into real use cases. webassembly wasm edge-computing GitHub Copilot: First Impressions From a Go Developer · 4 min I got early access to GitHub Copilot's technical preview. Here's what it actually does well, what it gets wrong, and why I'm cautiously interested. github-copilot ai developer-tools 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. What I recommend after doing each wrong at least once. api-gateway go kong I Wrote Six Kubernetes Operators. Here's What Actually Matters. · 9 min Lessons from building production operators at Decloud: the reconciliation loop, controller-runtime patterns, and the mistakes that cost us sleep. kubernetes operators go Event-Driven Architecture: What I Got Wrong and What Survived · 10 min Lessons from building event-driven systems at the fintech startup and Decloud: what works, what silently corrupts your data, and Go patterns that hold up. architecture events go 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 How I Build CLI Tools in Go (And Why I Stopped Overthinking It) · 8 min A deep dive into building Go CLIs that feel right: cobra patterns, structured output, signal handling, and the small decisions that separate a script from a tool. cli go tooling Message Queues: The Patterns Nobody Tells You About Until 3 AM · 8 min Queues look simple on a whiteboard. Then you deploy them. The messaging patterns I've learned the hard way across three startups, with real failure stories. messaging architecture rabbitmq 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 2016: The Year I Stopped Fighting Infrastructure · 5 min A personal look back at 2016 -- Docker going mainstream, Kubernetes momentum, Go adoption, and lessons from building at Dropbyke and a fintech startup. year-in-review technology engineering 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. go backend engineering
All topics →