Find a focused learning path or jump straight to the newest field notes. Every series lists all of its posts and starts with post 1—no manual table or month-by-month hunting required.

Newest production notes

Choose a series

85 posts

Building an Enterprise AI Agent Platform in Go

Enterprise AI agents in Go: a practitioner series on production runtimes, workflows, SRE triage, and platform lessons from Aiden at StackGen.

View all 85 post titles
  1. Go vs Python for AI Agents: Concurrency, Deployment & Tools
  2. TOML Over YAML and PKL — How We Stopped Fighting Config and Started Shipping
  3. Go Platform Architecture at Speed — Without Drowning
  4. Implementing ReAcTree — 6 Production Bugs the Paper Didn't Warn You About
  5. Pensieve — Memory Management for AI Agents That Actually Forget
  6. Agent Skill Distillation Without Fine-Tuning
  7. The HITL Paradox — When Human Approval Makes Agents Worse
  8. Your Agent Has Root — Defense-in-Depth for AI Agents That Wield Real Tools
  9. You Can't Debug What You Can't See — Observability for AI Agents
  10. Terraform for Agent Configuration — Infrastructure as Code Meets AI Governance
  11. AI Agent Runtime vs Platform — Why We Split Them
  12. Contributing Back While Building a Commercial Product
  13. Why One JSON Repair Pass Isn't Enough for Production Agent Tool Calls
  14. Evidence-Gated RCA — Prove, Then Narrate
  15. AI Incident Triage for SREs — What Actually Helps On-Call
  16. Evidence-Based Verification — Don't Trust Self-Report, Check the System
  17. LLM Tokenomics for Production Agents — Context Budgets as an Operating Model
  18. How We Debug Multi-Stage AI Agent Workflows
  19. Your RCA Agent Doesn't Need Another Runbook — It Needs a Map
  20. Beyond Confluence Runbooks: Why GitOps Triage Steps Matter in the AI Era
  21. The Diary Learning Loop — From Daily Agent Digests to Human-Approved Policy
  22. From Demo to Deploy — Failure Modes with Receipts
  23. The Hypothesis Ladder — Ruling Things Out Before You Narrate
  24. When Your AI Agent Scorecard Lies
  25. Is the Task Actually Done? — Completion Loops for Production Agents
  26. AI Agent Root Cause Analysis — Curiosity Before Confidence
  27. Be Creative. Don't Invent.
  28. AI Agent Root Cause Analysis — Evidence Discarded After the Lead
  29. AI Agent Loop Detection — Don't Throw Away the Answer
  30. Prompt Caching for AI Agents Is an Architecture Problem
  31. How to Interrupt, Redirect, or Contain an AI Agent Mid-Run
  32. PII Redaction for AI Agents — Two Views, One Trace
  33. SRE for Agentic Systems: Why Uptime Isn't Enough Anymore
  34. What Is an AI Agent Runtime? (Not a Chatbot or Platform)
  35. What Are SRE AI Agents?
  36. Aiden the Hard Way: Vague GitHub Issues to Review PRs
  37. Aiden the Easy Way: One Module from Vague Issue to Review PR
  38. Single-Agent vs Multi-Agent Orchestration: How to Choose
  39. Claim-Aware Evidence Packing — Don't Accuse Agents of Inventing What You Truncated
  40. Reasoning Effort Is Not a Free Upgrade for Tool-Heavy Agents
  41. AI SRE Agent Benchmarks: Wall Time, Tool Calls, Tokens, and ReAcTree Tax
  42. Canary First: Lessons from Black-Box Consistency Evals for Live SRE Investigate
  43. From Vibes to Contracts: How We Rebuilt Agent Evals Around an Industry Standard
  44. Fair Agent Evals: Don't Compare Planner vs Single-Agent Until Tools Match
  45. Agent Orchestration Tax: Tokens, Iterations, and Tool Calls After a Fair Eval
  46. AI Agent Eval Failure Modes: Budget, PII Placeholders, and Self-Reported Passes
  47. Stop Spawning Duplicate Workers: What a Handoff Gate Changed in Agent Evals
  48. Running AppWorld Locally for Aiden Agent Evals: Docker Compose, MCP, and Things We Wish We Knew Upfront
  49. How to Evaluate AI Agents: Ban Clarifying Questions and Zero-Tool "Success"
  50. Multi-Agent vs Single-Agent: When Planning Beats Reacting (MCP Tool Tax + pass@k)
  51. Simple vs Plan: When to Use Which (AppWorld smoke cohort)
  52. Observation Masking Cut Token Cost 43%—Then Lost the RCA
  53. Weekly Reflection: Context Engineering Beat the Language Wars
  54. Cursor paging for spilled agent tool output
  55. What Is ReAcTree? Hierarchical Agent Trees for Long-Horizon Work
  56. Six Model×Orchestration Combos on One Alert+Logs Job
  57. What Reasoning Models Write When You Ask Them to Triage
  58. Observability Tools Agents Actually Call on Triage
  59. Hierarchical vs Single-Agent on a Dual-Part Observability Job
  60. Stop Retrying the Same Failed Observability Query
  61. Relative Efficiency Scores Lie When Absolute Wall Doubles
  62. Best Way to Debug a Multi-Step AI Agent: A Trace-First Checklist
  63. Reasoning vs Generate Models for Tool-Heavy Agents
  64. How to Evaluate an AI Agent for Root Cause Analysis
  65. AI Agent Runtime: What to Measure Before You Buy
  66. Hybrid Plan Mode: Smart Planner, Generate Digs
  67. Chat Completions vs Responses API: Latency, Tools & Reasoning
  68. Session Efficiency Should Not Beat Accuracy
  69. Same Incident, Five Models: Rank Investigators Without Mixing the Exam
  70. AI Agent Evaluation: Why the Grader Must Be Separate
  71. The AI Agent Testing Pyramid: What Belongs in CI?
  72. Deterministic Checks vs LLM-as-a-Judge for Agent Evals
  73. How to Test AI Agent Loops Without Overfitting
  74. Multi-Agent Handoff Testing: Catch Context Loss Before Production
  75. AI Agent Evals in CI/CD: Flakes, Retries, and Missing Results
  76. Supervised E2E Learning Loop for AI Agents (Not Auto-Merge)
  77. Two E2E Feedback Loops: Coverage Gaps vs Failure Fixes
  78. When Is an E2E Finding Actually Closed?
  79. E2E Learning Loop Blind Spots: Skip-as-Success and More
  80. Why Open Policy Agent for AI agent guardrails
  81. Authorize AI agent tool calls with OPA
  82. Manage AI agent policies as code with Terraform
  83. Time-based AI agent policies with OPA
  84. Guardrails and human approval for AI agent tool calls
  85. LLM Performance Metrics — From Lighthouse to the Token Era (related note)

45 posts

ClickHouse on AWS: Self-Managed from First Principles

Self-managed ClickHouse on AWS for engineers starting from first principles: MergeTree internals, engine choices, cluster topology, S3 storage, spot readers, operations, and cost — with the numbers and failure stories behind each choice.

View all 45 post titles
  1. A Junior Engineer's Guide to ClickHouse: The MergeTree Mental Model
  2. SharedMergeTree vs ReplicatedMergeTree: Picking a ClickHouse Engine When You Don't Have ClickHouse Cloud
  3. Writers, Readers, Keepers: Designing a ClickHouse Cluster That Survives Node Loss
  4. ClickHouse on S3: Tiered Storage Policies That Don't Melt
  5. Running ClickHouse Readers on Spot: The Stable-Identity Problem
  6. Operating Self-Managed ClickHouse: Golden Images, Bootstrap, and Runbooks
  7. The Cost Levers of Self-Managed ClickHouse on AWS
  8. After ReplicatedMergeTree: CAS, Iceberg, and When to Just Buy ClickHouse Cloud
  9. Why I Draw ClickHouse Data Flows (and Why EC2 Beat Kubernetes for This Cluster)
  10. ClickHouse Config Is Not YAML: What One Re-Render Taught Me About Replica Identity
  11. The S3 Path Bug Nobody Sees: Silent Config, Shattered Tenants, and a CAS-Ready Fix
  12. Teaching an Operator Without Kubernetes: Building chctl From the Altinity Source
  13. Boot Sequence as a Contract: How a Self-Managed ClickHouse Node Comes Up (and How It Fails)
  14. Dead Projections and Useless FINAL: Tuning ClickHouse Tenant Databases by Reading the Source
  15. A Field Map of ClickHouse Storage: Disks, Object Stores, and Metadata in the Source
  16. Destroy, Then Create: The Ordering Rule That Keeps Static-IP ClickHouse Replaceable
  17. One Binary to Bootstrap a Node: Why chinit Replaced 3,600 Lines of Bash
  18. Dissolving the Second Binary: How chinit Absorbed Its Own Companion CLI
  19. Who Decides What a Node Is Called? Lease Identity for an Ephemeral Stateful Fleet
  20. Adopting the Pattern: A Migration Guide for Declarative Node Bootstrap and Lease Identity
  21. ClickHouse zero-copy replication is dead: the content-addressed design that replaced it
  22. Touching CAS Without Betting the Cluster: A Hands-On Staging Walkthrough
  23. What Breaks with ClickHouse CAS, and How to Decide If You Should Run It
  24. Draining 29,000 S3Queue Files Fast: Every Setting That Matters (With Source Code)
  25. Three Days of Keeper Silence: How a Lost Metric Push Made a Healthy Cluster Blind
  26. The Self-Terminating Alarm: When Per-Host Scale-In Kills Every Scale-Out
  27. When df Lies: keep_free_space, Effective Disk Headroom, and a Fleet That Grows Its Own Volumes
  28. The Honest Cost Model: Load-Testing a Log Stack Until the Bill Tells the Truth
  29. The Fleet That Could Not Heal Itself: TLS Storms, Dead DNS, and What 'Self-Healing' Actually Requires
  30. Graviton Roulette: The Day NVMe Device Names Broke Our Boot (and the Disk-Label Guard That Saved Root)
  31. S3Queue Is a Multi-Node Engine: Stop Bottlenecking Ingest on One Writer
  32. The Cloud-Neutral Bootstrapper That Wasn't: Auditing chinit for Azure and What It Taught Us About Portability
  33. From an Empty EC2 Box to a Cluster Member: What Bootstrapping ClickHouse on AWS Actually Means (and What chinit Does at Every Step)
  34. The Roster, the Journal, and the Bookmarks: What Actually Happens When You CREATE a Replicated ClickHouse Table
  35. The Five-Round Brawl to Make Schema Convergence Automatic: Bootstrapping ClickHouse Tables That Refuse to Converge
  36. Postgres Was a Filing Cabinet. ClickHouse Is a Warehouse: From Zero to SharedMergeTree for SQL People
  37. The Loading Dock and the Clipboard: What a ClickHouse S3Queue Table Actually Is
  38. Free Is a Route, Not a Setting: The S3 Gateway Endpoint at 30 TB/day
  39. Don't Ship Tarballs to a Column Store: ClickHouse Compression from S3Queue to MergeTree
  40. Why the Fix Didn't Fix It: Stopping a 16.8M-Request S3 API Storm in a ClickHouse Fleet
  41. Why ClickHouse Looked 30% Busy While Maxed Out: The 125 MB/s EBS gp3 Wall
  42. The Math of ClickHouse CAS on AWS: How Content-Addressed S3 Cuts Cold Storage from R× to 1×
  43. Meet chinit: Running ClickHouse on Plain Cloud VMs Without Missing Kubernetes
  44. Three Generations of a 30 TB/Day ClickHouse Fleet: Non-CAS vs. CAS, What Broke, and a Blueprint for Self-Managed S3
  45. 100 TB/Day ClickHouse on AWS: Continuous Spot Data Flows, NVMe Cache, and CAS Cold-Tier Cost

12 posts

Service Rendered Efficiently

SRE as Service Rendered Efficiently — a series on AI investigation as a service product for on-call teams, not an engineering credibility project.

View all 12 post titles
  1. Service Rendered Efficiently: SRE AI Is Not an Engineering Credibility Project
  2. Stop Re-Investigating the Same Alert
  3. Slack Is a Triage Board, Not a Log Dump
  4. Same Alert, Different Verdict: Entry Path Is Context
  5. When the Operator Asks to Correlate, Make It a Gate
  6. AI Agents Call Truncated Grafana 'No Data'—It's Spill
  7. AI Agent Hit Max Turns? Deliver Partial RCA, Not Apology
  8. Ungrounded Synthesis Must Read as Hypothesis
  9. Empty PromQL ≠ Missing Data: Fix AI SRE Scope Blindness
  10. Don't Invent PromQL: Measure the Alert Rule Query First
  11. Why AI SRE Feels Stuck Before the First Tool Call
  12. Debug AI Agent Failures: One Zip Per Conversation

Standalone production notes

Browse across series

FAQ

How many series does this site have?

Three: Building an Enterprise AI Agent Platform in Go, ClickHouse on AWS, and Service Rendered Efficiently. Each series card below shows its current post count and complete reading order.

How do I read a series from beginning to end?

Choose Start with post 1 or open the full reading order. Every article ends with a Next in series link, so you can continue without returning to the archive.

Where do standalone posts live?

Standalone production notes appear on this page below the series. The newest notes section also includes recent posts from every series and standalone topics.