↵ select ↓ ↑ navigate esc close

Seroter's Daily Reading: Daily Reading List – October 27, 2026 (#897)

Seroter's Daily Reading ·

Listen: https://blossom.buildtall.systems/7f43ba8082d980852c5738fd660c6927599aed05da32ed93c800cf6586c30ab0.mp3

Source: https://seroter.com/2026/10/27/daily-reading-list-october-27-2026-897/


This episode covers Richard Seroter's Daily Reading List for October 27, 2026, number 897. Seroter opens by noting that yesterday's list had a pile of good advice, and today's does too, spanning test-driven development, measuring AI productivity, day-2 operations, and making documentation agent-ready.

John Arundel's post Dancing backwards with Go: why TDD is weird uses the analogy of Ginger Rogers dancing backwards in high heels to explain test-driven development. The core idea is to write the test before the function, then write just enough code to make the test fail, then make it pass, and finally refactor. Arundel walks through building an IsSorted function in Go, starting with a failing test, using the Shameless Green approach, and gradually adding edge cases like negative numbers, repeated elements, and empty slices, eventually replacing the custom logic with the standard library's slices.IsSorted. Seroter comments that TDD can feel weird in any language, writing the failing test first and then making it pass, and adds that he's not sure how well LLMs comprehensively do it.

Next, How to measure AI productivity? by Nurkhon Akhmedov. Seroter says this is still a remarkably important question: you say you're saving time with AI, but what outcomes changed? His advice is to measure the waiting, not just the individual tasks. Akhmedov lays out five numbers to track: time per task before and after, how long work waits before someone can build it, rework and back-and-forth, review time, and product outcomes. He shares data from Workday showing 85% of employees save time but nearly 40% of that savings is lost to rework, and from NBER that nine in ten firms using AI report no productivity impact. On his own team, tasks got much faster, but a sprint still ran dry because discovery, design, and decisions became the bottleneck. The fix was upstream: making sure work was ready before the sprint started, and having PMs ship small changes themselves from a dev container.

Tokenomics (Or the right tool for the right job) from Fintan Ryan's blog. Seroter notes that matching token use to outcomes isn't easy for anyone, and that's enough to drive a CFO bonkers. The article highlights the Linux Foundation's State of Tokenomics report, with 472 responses across 11 industries. It finds that organizations use multiple models and providers, with 96% using a model provider directly and 87% using a hyperscaler, and a clear bias toward open weight models. But only 14% of respondents are very confident in their AI spend visibility, and 74% cannot confidently prove AI business outcomes to the CFO. The author argues there is a rapid bifurcation: commodity tokens from cheaper models are getting cheaper, while advanced reasoning models remain far more expensive. The emerging pattern is an orchestration agent using a reasoning model that delegates work to cheaper models or tools.

The next link, From Python to Rust, Go, to… Java? Steering Your AI Coding Agent Through Architecture Trade-Offs, could not be retrieved, but Seroter's commentary gives the gist. He says to digest what Alexis is showing: vague requests to an LLM or agent yield default languages and architectures that may not match what you actually want. The prescription is to be clear about your application needs so that the default language matches your use case. Based on the title, the piece appears to be a practical look at how to steer an AI coding agent through architecture trade-offs, using examples that start with Python and Rust or Go, and may end up at Java when the requirements call for it.

Day 2000 Doesn’t Care How Fast You Shipped by Christopher Hedley of Syntasso. Seroter calls it truth, and asks: is your platform helping you maintain and operate all the software you're delivering? The article contrasts two worlds: in one, infrastructure is managed as a fleet with versioned promises and staged rollouts; in the other, you have thousands of individually provisioned services that become pets wearing cattle costumes. The recent eMudhra certificate authority compromise and PHP2Shell vulnerability are examples. Fixing a trust store across 3,000 services could cost 25 engineer-weeks if done manually, while a fleet-managed platform coordinates one change across all instances. Hedley also notes that vulnerability scanners often miss non-CVE trust issues, giving a false sense of security, and that the Go community shipped an actual CVE to block compromised intermediates.

Jason Davenport's 100% of your developers should be building things to improve the workflow. Are they? Seroter asks whether that's the case where you work, and suspects probably not, but wonders how to switch focus to the systems that produce the output. Davenport argues that developers tend to fix the execution output rather than the machine, using a commit history full of 'fix' and 'really fixed' as evidence. He frames agent lineage as a SIPOC problem: if try 11 fails, hand-fixing the output doesn't help try 12 because the process is still broken. The reasons people don't improve the system include ownership being dirty work and incentives being task-oriented. He recommends rewarding the dirty work around intent, test cases, and the harness, and investing in personal agent systems, because AI is a 200 mile per hour sports car that needs well-built roads.

The Git Forge for Agent-Human Collaboration, by Thomas Dohmke, co-founder and CEO of Entire. Seroter says he really likes where they've landed here, and that this looks like a legit alternative to traditional git solutions. Entire is built on three primitives: the Trail, which replaces the linear pull request with a heads-up display of automated evals scored by agents on every push; distributed Git hosting that is up to 89 times faster than GitHub; and Continuous Memory, which syncs agent sessions and prompts into the repository. The Trail lifecycle starts a trail from a bug or feature request, runs review agents that produce scores and findings, and only allows merge when confidence is high, risk is low, and all findings are closed. Entire also integrates with Buildkite and Depot for CI, and offers regional hosting for data residency.

Seroter's 'More here' link points to The New Stack coverage titled More here, by Frederic Lardinois, which reports on the Entire launch. The article frames it as the ex-GitHub CEO launching a GitHub rival that reinvents the pull request. It highlights that Entire's Trails are designed for agentic code review, where coding agents and review agents loop until scores stabilize, rather than the traditional human-driven review timeline. The piece also notes Entire's distributed architecture and its positioning for AI-native teams, reinforcing Seroter's view that this is a legitimate alternative to traditional git solutions.

Bringing Google TPUs to Oracle Cloud Infrastructure, from the Google Cloud blog by Karan Batta and Gurmeet Goindi. Seroter quips everybody gets a TPU, noting this valuable processor is getting wider access and more tools for using it. The announcement says Oracle Cloud Infrastructure will be the first hyperscaler outside Google to offer TPUs, with deployment starting in 2027. The article explains TPU co-design from silicon to software, with features like on-die interconnect and optical circuit switching sustaining over 97 percent goodput on large training runs, and up to 80 percent better performance per dollar for low-latency serving. OCI brings data centers engineered for AI density, secure networking with Oracle Acceleron, proximity to enterprise data in Oracle databases, and multi-architecture choice alongside GPUs. TorchTPU is now open source, letting developers use vLLM, SGLang, and other familiar tools on TPUs.

Keeping a software factory stable at 1,000 PRs a week, by Zejiang Guo, Bolin Chen, and Zezhen Xu of Kiro. Seroter's takeaway is to build things to improve the workflow, and increase your trust in the system. The post describes how three engineers and a crew of agents merged 1,000 pull requests in one week, and the bigger challenge of maintaining quality at that speed. The team argues that confidence comes from automated tests and checks, not from a human reading every line. They spend about 20 percent of their time on infrastructure that automates more. The article walks through five stages: from human review, to an automated reviewer, to severity tiers and a second reviewer, to full CI with many specialized reviewers, to a closed loop where a skill called prepare-pr drives the PR to green. They also cover post-merge release gates, security scanning, periodic refactoring, and handling the biggest problems: over-engineering and security fixes that go too far.

Are agent harnesses dying? What harness distillation changes, by Laurie Voss on O'Reilly Radar. Seroter says today's harnesses may be unnecessary in six months because the model will do it, but he imagines we'll want something that sits outside, even if only for the option to swap models. The article explains harness distillation, where a research team trained the behavior of a specialized agent harness into a small model, then removed the harness and found the distilled model beat the original model plus harness. The key is training on corrected runs, where fixes are within the model's capacity, rather than on perfect runs. Voss argues that general scaffolding will continue to be absorbed by models, following the Bitter Lesson, but the parts tied to your tools, data, users, and environment still belong in the harness. He recommends a practical maintenance loop: tag traces with harness and model version, log each intervention, and when a new model ships, turn off components one at a time to see what still helps.

Making documentation pages agent friendly, by Tom Johnson. Seroter says his team is doing a lot of work here, and that Tom encourages everyone to understand how agents see their docbase. Johnson explains that most agent fetch tools don't run JavaScript, so content that loads only on click is invisible, while content hidden with CSS still comes through. Long pages get truncated, and agents often fill the gaps with guesses, leading to hallucinations. He recommends breaking up long pages, avoiding JavaScript-only content, and providing a Markdown mirror by appending .md to page URLs, which he set up with a Cloudflare worker. He also notes that the Agent-Friendly Documentation Spec recommends keeping pages under 50,000 characters, and that a markdown version can be far smaller in tokens than the HTML page.

Testing and Serving A2A Agents from the Terminal with A2A CLI could not be retrieved, but Seroter describes it as a good walkthrough of a useful tool for interacting with agents over A2A, the Agent-to-Agent protocol. Based on the title, the article appears to be a practical guide from Google Cloud on using a command-line interface to test and serve A2A-compatible agents directly from the terminal, likely covering setup, testing, and serving without needing a full runtime environment.

Finally, The push to modernize legacy tech from Nextgov/FCW, by Edward Graham. Seroter's comment is that it's not hard to regenerate code, but you still need a good reason, and must be aware of the risks. The article examines how federal agencies are balancing the push to adopt AI and modernize with the reality of legacy systems. It covers the security challenges of hardening decades-old infrastructure, the VA's troubled electronic health record overhaul from VistA to Oracle, and the FAA's air traffic control modernization. Officials stress that new technology is not a substitute for fixing bad processes, and that change management is often the biggest barrier. The FAA is taking a slow approach to AI in the airspace even as it rolls out electronic flight strips. Seroter's point about regenerating code fits: modernization is easy in theory but the surrounding people and process risks are the real challenge.

Across this reading list, a few themes stand out. AI is making individual tasks faster, but the real questions are whether the system around those tasks improves, whether we trust automated workflows enough to let them run, and whether we're building platforms and docs that agents can actually operate. Seroter's selections repeatedly come back to measuring outcomes, fixing the machine, and preparing for day two thousand.

  1. Daily Reading List – October 27, 2026 (#897)
  2. Dancing backwards with Go: why TDD is weird
  3. How to measure AI productivity?
  4. Tokenomics (Or the right tool for the right job)
  5. From Python to Rust, Go, to… Java? Steering Your AI Coding Agent Through Architecture Trade-Offs
  6. Day 2000 Doesn’t Care How Fast You Shipped
  7. 100% of your developers should be building things to improve the workflow. Are they?
  8. The Git Forge for Agent-Human Collaboration
  9. More here
  10. Bringing Google TPUs to Oracle Cloud Infrastructure
  11. Keeping a software factory stable at 1,000 PRs a week
  12. Are agent harnesses dying? What harness distillation changes
  13. Making documentation pages agent friendly
  14. Testing and Serving A2A Agents from the Terminal with A2A CLI
  15. The push to modernize legacy tech