AI Engineering on Mengboy Tech Notes

Claude Code + GitHub Actions CI Self-Healing Pipeline: Error Attribution, Minimal Patches, and Human Approval Gates

Mon, 06 Apr 2026 01:17:34 +0000

If your CI keeps failing and engineers keep babysitting logs, you’re paying an invisible velocity tax. A production-grade AI self-healing pipeline is not “let the agent edit anything”. It’s a controlled loop: attribution, patching, approval, rollback.

This post gives you a deployable baseline: Claude Code proposes a minimal fix patch, GitHub Actions enforces risk gates and regression checks, and humans only approve at high-impact checkpoints.

Claude API Rate-Limit Storm Playbook: Adaptive Concurrency, Jittered Backoff, and Quota Isolation

Fri, 03 Apr 2026 01:15:05 +0000

When Claude API starts returning 429 under high load, most systems don’t just slow down—they collapse: queue buildup, retry storms, upstream timeout chains, and pager noise.

OpenAI Responses Streaming in Production: Backpressure, Chunk Reassembly, and Timeout Budget

Fri, 27 Mar 2026 01:08:00 +0000

Most streaming failures are not about “can it stream”, but “does it stay stable under load”: broken chunks, stuck clients, timeout cascades, and retry storms.

Claude + OpenAI Model Routing Gateway: Latency Tiers, Cost Caps, and Quality Guardrails

Wed, 25 Mar 2026 01:16:31 +0000

Connecting both Claude and OpenAI in production is the easy part. The hard part is keeping the system stable across the quality-latency-cost triangle.
Without a routing gateway, you usually get latency spikes, runaway bills, and ugly cascading failures.

OpenAI Responses + Go Stream Recovery: Delta Persistence, Resume Tokens, and Duplicate Chunk Dedup

Mon, 23 Mar 2026 01:13:09 +0000

In production, the painful part is not “streaming is slow.” It’s “streaming breaks and then duplicates output after reconnect.”
This guide gives you a practical recovery loop: delta persistence + resume token + idempotent dedup, so reconnection does not replay garbage.

OpenAI Responses in Go Multi-Tenant Quota Governance: Token Buckets, Budget Circuit Breakers, and Cost Attribution

Fri, 20 Mar 2026 01:08:00 +0000

Most multi-tenant AI platforms fail for two boring reasons: one tenant saturates shared capacity, and finance discovers the burn too late.

This guide gives you a practical Go blueprint: token-bucket throttling, budget circuit breakers, and request-level cost attribution.

Go + OpenAI Responses Agent Memory Layering: Short-Term Context, Long-Term Index, and Cost Caps

Wed, 18 Mar 2026 16:33:52 +0000

In production Go agents, the first thing that breaks is usually not model quality. It is memory management: context grows, bills spike, and answers drift.

Use a 3-layer memory design:

L1: short-term conversational window (seconds)
L2: rolling summary (minutes)
L3: long-term retrieval memory (days)

Handling OpenAI 429/5xx Storms in Go: Token Bucket, Exponential Backoff, and Circuit Breakers

Wed, 18 Mar 2026 01:14:00 +0000

Most Go teams are not killed by a single API error. They are killed by a retry storm they created themselves.

OpenAI Responses + GitHub Actions PR Risk Gate: Automated Evals, Tiered Blocking, and One-Click Rollback

Mon, 16 Mar 2026 01:08:00 +0000

You don’t need an AI reviewer that “sounds smart.” You need a gate that stops risky PRs before they hit main.

This post shows a production-ready minimum setup: OpenAI Responses generates structured risk output, GitHub Actions enforces tiered policies, and critical failures can trigger a one-click rollback.

OpenAI Batch API with Go: Offline Batching, Failure Replay, and Cost Boundaries

Fri, 13 Mar 2026 01:08:00 +0000

Short answer: if your workload is delay-tolerant, batchable, and replay-safe, move it from online calls to Batch API. The savings are real, but only if you design splitting, failure routing, and replay first.

Many teams treat Batch API as a cheaper sync endpoint. That usually creates a replay mess instead of stable savings. A conservative rollout starts with cost boundaries and SLOs, then implements offline batching and controlled replay.

OpenAI Responses Structured Outputs with Go: Schema Evolution, Bad-Case Fallbacks, and Gradual Rollback

Wed, 11 Mar 2026 01:08:00 +0000

The hardest part of Structured Outputs is not getting JSON once. It is surviving schema changes without turning production into a small fire with excellent logs and terrible business results.

Once a Go service starts evolving prompts and response contracts, the usual failure modes show up fast: a new required field breaks older consumers, an enum expands and strict validation kills valid requests, or one bad sample drags the whole chain into retries and rollback panic.

OpenAI Realtime + Go in Production: WebRTC Token Rotation, Interruption Recovery, and End-to-End Latency Budgets

Mon, 09 Mar 2026 01:13:00 +0000

If you plan to put OpenAI Realtime into production, do not let a passing demo fool you.

What usually breaks the system is not the model itself. It is non-rotating short-lived auth, missing interruption state, and zero end-to-end latency budgeting. Miss those three and your voice UX starts sounding like an angry walkie-talkie.

Go + OpenAI Responses: Connection Pooling and Timeout Budgets from HTTP/2 Reuse to Error-Budget Control

Fri, 06 Mar 2026 01:13:12 +0000

When Go services call the OpenAI Responses API in production, the real failures are rarely about model quality. Most incidents come from transport instability: weak connection pooling, conflicting timeout layers, and retry storms.

This guide gives you a practical baseline: HTTP/2 reuse, layered timeout budgets, bounded retries, and error-budget driven operations.

OpenAI Responses + Go: Taming Retry Storms with Idempotency Keys, Jittered Backoff, and Circuit Breakers

Wed, 04 Mar 2026 01:10:40 +0000

The most expensive outage is not a single failure — it is a failure amplified by retries.

In an OpenAI Responses + Go tool-calling stack, missing idempotency, jittered backoff, and breaker thresholds can turn 10 failing requests into 1000 downstream calls in minutes.

Taming Context Explosion in OpenAI Assistants/Responses with Go: Truncation, Summary Backfill, and Cost Caps

Mon, 02 Mar 2026 12:44:00 +0000

Long-running agent sessions usually fail the same way: context keeps growing, latency spikes, costs blow up, and answer quality gets worse.

That is rarely a model-quality issue. It is almost always missing context governance.

Go + OpenAI API Timeout Troubleshooting: DNS, TLS, Proxy, and Connection Pool

Mon, 02 Mar 2026 01:12:10 +0000

When OpenAI API calls start timing out in production, the real problem is usually not “OpenAI is down.”

The real problem is you don’t know which hop is failing: DNS, TLS handshake, proxy path, or your own connection pool.

GitHub Actions + AI Agent Auto-Fix Pipeline: Failure Tiers, Regression Gates, and Security Guardrails

Fri, 27 Feb 2026 01:18:38 +0000

When CI keeps failing, the real risk is not “slow fixes” — it is “fast bad fixes.” This guide gives you a practical GitHub Actions + AI Agent auto-fix pipeline with failure tiering, strict edit boundaries, and merge-time gates.

OpenAI Agents SDK with Go: Tool Calling, Session Memory, and Error Recovery

Wed, 25 Feb 2026 01:18:00 +0000

Most teams can connect an LLM in a demo. The real pain starts in production: multi-step tasks, flaky tool calls, unclear retries, and rising cost.

This guide gives you a pragmatic Go-first blueprint for shipping an Agent workflow that can survive real incidents.

OpenAI Responses API Streaming in Go: Timeouts, Retries, and Observability

Mon, 23 Feb 2026 01:15:00 +0000

Production streaming fails in two predictable ways: users wait while the stream silently drops, and your logs say “timeout” without telling you where it actually broke.

This guide gives you a practical Go pattern for OpenAI Responses API streaming with strict timeout boundaries, safe retries, and useful telemetry.

Claude Code + Codex for Multi-Model Development: Cost, Speed, and Quality (Practical Workflow)

Sun, 15 Feb 2026 10:30:00 +0800

If you still use one model for everything, you usually pay in one of three ways: higher cost, slower delivery, or more rework.

A better setup is role-based collaboration: Claude Code for planning and quality gates, Codex for fast implementation and batch edits.