Testing AI Where It Actually Runs
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.
Golang
Definition
Golang coverage in this archive spans 17 posts from Nov 2016 to Apr 2025 and leans into practical engineering craft: interfaces, testing, and maintainable implementation details. The strongest adjacent threads are ai, architecture, and backend. Recurring title motifs include go, ai, practice, and patterns.
Key claims
- The through-line is clarity first: simple designs that survive change beat clever abstractions.
- Early posts lean on go and stopped, while newer posts lean on go and event as constraints shifted.
- This topic repeatedly intersects with ai, architecture, and backend, so design choices here rarely stand alone.
Practical checklist
- 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 architecture before committing implementation details.
Failure modes
- 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 2025 without revisiting assumptions as context changed.
Suggested reading path
- Start here (current state): Testing AI Where It Actually Runs
- Then read (operating middle): Feature Flags at Scale: What Nobody Warns You About
- Finish with (foundational context): Why We Chose Go for Our Backend Services
Related posts
- Testing AI Where It Actually Runs
- MCP in Practice: Building Tool Servers in Go
- AI Code Review Is Mostly Noise
- Reasoning Models in Production: A Practical Guide
- Go Concurrency Patterns I Use in Every Service
- TypeScript: A Go Developer’s Honest Take
- OpenTelemetry in Late 2021: What’s Ready and What’s Not
- Event Sourcing in Practice: What I Learned Building Financial Event Pipelines
References
MCP in Practice: Building Tool Servers in Go
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.
AI Code Review Is Mostly Noise
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.
Reasoning Models in Production: A Practical Guide
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.
Go Concurrency Patterns I Use in Every Service
Worker pools, fan-out/fan-in, pipelines, and the cancellation discipline that keeps Go services predictable under load.
TypeScript: A Go Developer's Honest Take
TypeScript is the best thing to happen to JavaScript. That bar is lower than people think. Here's what actually matters for large codebases.
OpenTelemetry in Late 2021: What's Ready and What's Not
Tracing is ready. Metrics are getting there. Logs are not. Here's a practical adoption path and the code to back it up.
Event Sourcing in Practice: What I Learned Building Financial Event Pipelines
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.
Feature Flags at Scale: What Nobody Warns You About
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.
WebAssembly Beyond the Browser: A 2021 Progress Report
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.
GitHub Copilot: First Impressions From a Go Developer
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.
I Wrote Six Kubernetes Operators. Here's What Actually Matters.
Lessons from building production operators at Decloud: the reconciliation loop, controller-runtime patterns, and the mistakes that cost us sleep.
Event-Driven Architecture: What I Got Wrong and What Survived
Lessons from building event-driven systems at the fintech startup and Decloud. What actually works, what silently corrupts your data, and Go patterns for handling events without losing your mind.
How I Build CLI Tools in Go (And Why I Stopped Overthinking It)
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.
Message Queues: The Patterns Nobody Tells You About Until 3 AM
Queues look simple on a whiteboard. Then you deploy them. Here are the messaging patterns I've learned the hard way across three startups, with Go code and real failure stories.
2016: The Year I Stopped Fighting Infrastructure
A personal look back at what mattered in 2016 -- Docker going mainstream, Kubernetes momentum, Go adoption, and lessons from building at Dropbyke and a fintech startup.
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.