↵ select ↓ ↑ navigate esc close

Seroter's Daily Reading: Daily Reading List – October 14, 2026 (#888)

Seroter's Daily Reading ·

Listen: https://blossom.buildtall.systems/b51a9176b339add6535e6fb53162e3135215d62c195b234da048afa381e0ac21.mp3

Source: https://seroter.com/2026/10/14/daily-reading-list-october-14-2026-888/


Daily Reading List – October 14, 2026 (#888). Richard Seroter opens by urging readers to ask a question after reading each headline: why didn’t OKRs work, why are predictability and outcomes at odds, how many pilots of any kind actually reach production, and why rewrite all your code? His framing is to be good question-askers and seek answers.

First is

You didn’t do it right.

by Jason Cohen. Jason describes four sincere attempts to implement OKRs at WP Engine, all of which failed. Each time, experts told him he didn’t do it right. He argues that this response rests on what he calls the precision fallacy: the framework is assumed to always work, so every failure is blamed on the implementer. Instead, he says frameworks fit only some contexts, and teams should try them on like clothes, tailoring as needed. What worked for his teams was a metrics framework built around one metric the team personally wanted, then growing from there. Seroter’s take is that every measurement framework isn’t right for every team, and this is often less a knowledge problem than the wrong context for it to work.

Next is “38 things we’ve learned about building AI products” from PostHog, written by Ian Vanagas. It compiles lessons from four years and ten AI products. Among the highlights: AI can make a product worse, building for AI with things like MCP servers can outperform a standalone assistant, context is the real moat, reliability matters more than raw capability, and missing tools are essentially feature requests written by robots. It also emphasizes agent observability, shared AI infrastructure, and letting agents run code. Seroter calls it a fantastic list and recommends digesting it even if you have your own lessons.

Google Cloud’s “One Agent Development Kit, five languages” by Karl Weinmeister explains that the Agent Development Kit now supports Python, Go, TypeScript, Java, and Kotlin with shared MCP and A2A protocols. That means teams can build interoperable agents without being forced into a Python-only stack. The post walks through how each language version fits its runtime, from Go’s compiled concurrency to Kotlin’s build-time safety. Seroter sees value in a common framework across languages if you’re building code-based agents, though he notes that may not be the dominant approach as pre-built general agents fed custom skills become more common.

Then “Predictability vs Outcomes” from SVPG reframes a familiar product debate. The author argues that the real tension is not output versus outcomes, but predictability versus outcomes. Output is still needed to achieve outcomes, so that is not the real trade-off. The deeper issue is that many organizations prioritize predictable delivery over discovering what actually works. The piece connects this to project models and frameworks like SAFe, and says outcomes require humility and product discovery. Seroter says this one made him stop and think, precisely because it moves beyond output versus outcomes to the decision between predictability and outcomes.

The customer story “How Anthropic scales telemetry and billing data with Pub/Sub” details how Anthropic uses Google Cloud Pub/Sub to ingest over a million events per second, more than five hundred billion daily rows per topic, and three gigabytes per second of training metrics, with sub-second latency. It also describes a dual-path pipeline for large payloads, a migration to StreamingPull that cut consumer-side latency by 88 percent, and a self-service event platform built on Protobuf schemas. Seroter calls the stats pretty wild and sees it as a testament to using an at-scale cloud messaging engine.

Seroter then highlights “How to Manage Context in AI Agents” by Shir on Medium. This article is about managing context in AI agents. Seroter says the whole area feels unsettled to him, but Shir articulates the options well, and practitioners are still debating the merits of these approaches.

“Previewing Gemini 4 Argon by Building an AR Game for My 4-Year-Old” is another article represented here by Seroter’s commentary. The title suggests a hands-on preview of Gemini 4 Argon through an augmented reality game built for a young child. Seroter’s take is that a four-year-old is a tough customer, and the exciting part is how quickly ideas can be realized now.

The New Stack piece “Why 88% of AI pilots never make it to production” puts a stark number on a familiar challenge. Seroter accepts the statistic but adds important context: twenty to thirty percent of all pilots make it to production, so the difficulty is not unique to AI. He says it’s hard for technology to go from a perfectly curated clean room to the rough-and-tumble production world.

“6 Years of Tech Debt, 1 Prompt: Modernizing a Legacy App with Gemini 4” is a demo by Mete. The title describes a six-year full-stack upgrade handled in a single prompt using Gemini 4. Seroter calls it an excellent demo scenario and says the idea of a six-year upgrade in one shot is remarkable.

“How to effectively debug when you no longer understand the code” by Cindy is, in Seroter’s description, a small novel in length. He praises it as a wonderful look at expertise, assumptions, and how to rethink the directions given to AI agents when the code is no longer fully understood.

InfoWorld’s “It’s time to rewrite all that old code” argues that coding agents have changed the old taboo against rewriting legacy applications. The author describes how Claude Code converted a BASIC Star Trek game to WebAssembly via Go in under a minute, and suggests agents can now understand and modernize large legacy codebases. Seroter is more cautious: sure, but first ask why, in what language, with which tool, and targeting which platform.

“Better HTTP/1 connection reuse” from the Go Blog explains a major performance improvement in Go 1.27. A simple HTTP status check that took about 710 milliseconds on Go 1.26 drops to roughly 150 milliseconds because the HTTP transport now automatically drains unread response bodies, allowing connections to be reused instead of abandoned. The post explains the cost of TCP and TLS handshakes and how Go now handles the complexity on the developer’s behalf. Seroter calls it a geeky topic, but he likes knowing his language takes care of this kind of thing for him.

Finally, “Predictable AI spend in Big Query: Introducing cost management for generative AI functions” introduces token-based daily quotas for BigQuery’s generative AI SQL functions. Administrators can set project-level and per-user quotas for input and output tokens, monitor usage, and use AI.COUNT_TOKENS to size workloads before scaling. Seroter likes embedding LLM calls inside queries, but notes it’s probably easy to go overboard, and he’s glad quotas are in place.

Across the list, the questions Seroter asks at the start recur: which frameworks actually fit, whether code-based agents are the default, whether predictability or outcomes get priority, and whether rewriting old code is now responsible. The answers all point to matching tools to context, using guardrails thoughtfully, and letting infrastructure handle complexity.

  1. Daily Reading List – October 14, 2026 (#888)
  2. “You didn’t do it right.”
  3. 38 things we’ve learned about building AI products
  4. One Agent Development Kit, five languages
  5. Predictability vs Outcomes
  6. How Anthropic scales telemetry and billing data with Pub/Sub
  7. How to Manage Context in AI Agents
  8. Previewing Gemini 4 Argon by Building an AR Game for My 4-Year-Old
  9. Why 88% of AI pilots never make it to production
  10. 6 Years of Tech Debt, 1 Prompt: Modernizing a Legacy App with Gemini 4
  11. How to effectively debug when you no longer understand the code
  12. It’s time to rewrite all that old code
  13. Better HTTP/1 connection reuse
  14. Predictable AI spend in Big Query: Introducing cost management for generative AI functions