Source: https://seroter.com/2026/10/19/daily-reading-list-october-19-2026-891/
Today's episode covers Daily Reading List – October 19, 2026 (#891). Richard Seroter opens by saying he is in Sunnyvale at an Agentic AI Executive Forum where Google is hosting a couple dozen open source contributors, and that he has learned a lot.
First is Agentic Verification by Addy Osmani. Seroter's note is that now the hard part is figuring out if what we get from AI tools is what we wanted, and Osmani looks at a few verification approaches. The central argument is that the bottleneck has moved from writing code to knowing it is correct. Giving an agent a way to independently verify its work can heavily improve output quality. Osmani recommends end-to-end tests that simulate real user flows, property-based tests that generate thousands of cases to break constraints, and differential testing where an old system serves as the oracle for a new one. The verification loop must be fast and deterministic, because a slow or flaky loop teaches the agent to retry rather than fix problems. The human still owns what ships, but now reviews evidence instead of every diff.
Next is Turn Vibe-Coded Prototypes Into Tools Your Company Can Actually Use from Harvard Business Review. Seroter asks whether skipping a SaaS product renewal because you can build it yourself is wise, and answers maybe you can, but there are ways to ensure you are building something more than a toy. The piece argues that generative AI makes company-built software easier and cheaper than ever, while the real challenge is turning a promising vibe-coded prototype into a reliable, scalable, production-grade tool. The authors focus on the discipline required to move from demo excitement to operational readiness.
Then comes The Thin Orchestrator: How We Made Our AI Agents More Reliable by Giving the Router Less to Do from Meta engineering. Seroter says he liked this post and that it has very good advice for agent architectures. Meta's team started with a single smart agent that knew everything; it worked in demos but hallucinated in production. The fix was giving the central agent less to do: a deterministic orchestrator that routes work and runs reliability checks, plus fourteen specialized subagents that each load only the domain knowledge they need. That change reduced configuration preparation from days to under an hour. The key principle is to separate routing from reasoning, and to reuse existing agents through workflow templates rather than building new ones.
Seroter then links to Code Review After Code Gets Cheap by Markus Eisele. He says this is back to verification again, and warns that small changes can have a huge blast radius, so you should not blindly trust the AI output. Eisele's argument is that when code generation is cheap, review time is the scarce resource. He proposes evidence as a condition of accepting agent-generated code. A small diff, such as an agent quietly adding retries to a shared payment client while implementing an approval feature, can affect every caller and create unintended duplicate refunds. Reviewers should look for drift in both directions: missing required behavior and unexplained added behavior. Tests can share the same mistake as code, so the meaning of assertions still needs human attention.
The next item is Beyond Chatbots: How to Schedule Autonomous ADK Agents on GCP with Cloud Scheduler. Seroter uses it to ask how you are starting your agents: human triggers, event-driven moments, or time-based scheduling? He says this looks at the time-based option. The title indicates a Google Cloud guide for scheduling autonomous ADK agents with Cloud Scheduler rather than keeping them limited to chatbot interactions.
Then there is Personal software factories are a waste of time by Peter P. Seroter's take is that if you are going overboard building a customized software factory for all your development work, you should chill out. Peter argues that engineers naturally want to build their own factory, but it can become a comfort zone that keeps you from shipping real projects. Non-developers are already applying AI in impressive ways, while the factory builder is still working on infrastructure. Peter still encourages learning AI tools and building side projects, but says if you absolutely must build a factory, let it be at work, where you understand messy systems and can empower an entire team.
Next is Modernizing perimeter security: Scalable perimeters with VPC Service Controls from the Google Cloud blog. Seroter asks whether your network perimeter is set up to handle new types of workloads and interaction patterns, and says this seems like a good set of changes. The post announces enhancements to VPC Service Controls that make perimeters easier to create, maintain, and scale. Administrators can now add folders to perimeter membership, use folders and organizations directly in ingress and egress rules, and reference Private Service Connect endpoints. Service patterns in VPC accessible services allow only specific API URL patterns over private paths. Guided violation remediation proposes narrowly scoped fixes instead of forcing admins to open perimeters broadly. The framing emphasizes agents as a distinct category of non-human identity that needs secure-by-default guardrails.
Seroter then highlights Stacked PRs: what they are and how to run CI on a stack from CircleCI. He says you may have heard about stacked PRs but been unsure what they really are or how to use them. A stacked pull request is a PR whose base branch is another PR's branch rather than main, letting a large change be split into smaller dependent PRs. The article uses a rate-limiting example to show how config, middleware, handlers, and tests can be reviewed separately. The CI cost, however, can multiply when updating an earlier PR triggers pipelines across the stack. Techniques like path filtering, smarter testing, dynamic parallelism, and pre-push validation can reduce that overhead. The author also cautions that stacking works best when pieces are genuinely reviewable, not when managing the stack becomes its own burden.
Next is What requirements don’t you have? by Sean Goedecke. Seroter observes that real strategy is about what you are not doing, and some of the best architects know what not to require of their app. He adds that LLMs are not great at this and need human oversight. Goedecke's point is that the requirements you do not have are as important as the ones you do. Elegant systems drop something: Unicorn drops slow-client handling, S3 drops atomic multi-key updates, StatsD drops guaranteed delivery, and SQLite drops concurrent writes. With LLMs, the problem is that models are trained to satisfy graders, so they pile on unnecessary concurrency checks, mutexes, and edge-case handling. He recommends explicitly stating what you do not mind, such as stale cache data, and scanning AI-generated diffs for added coordination that was never requested.
Finally, Seroter highlights Step by Step guide: Build a Voice Agent That Never Goes Silent using ADK. He calls it good stuff and says he wants to get more hands-on, or agent-on, with this pattern of async tooling. The guide, by Stephen Allen and Kaz Sato, addresses dead air in live voice conversations when a tool takes thirteen seconds to complete. Instead of blocking the model, developers can use streaming tools that yield progress updates, or background execution that delivers the result at a natural pause. It also covers response scheduling modes like when idle, interrupt, and silent. In one benchmark, switching from a blocking tool to a streaming tool cut the time to first words from 14.4 seconds to 1.2 seconds.
Across the list, the theme is practical reliability for AI systems: verify outputs, isolate context, review blast radius, schedule agents deliberately, and know what requirements you can drop. It is a useful balance of moving fast with agents and keeping production discipline.
- Daily Reading List – October 19, 2026 (#891)
- Agentic Verification
- Turn Vibe-Coded Prototypes Into Tools Your Company Can Actually Use
- The Thin Orchestrator: How We Made Our AI Agents More Reliable by Giving the Router Less to Do
- Code Review After Code Gets Cheap
- Beyond Chatbots: How to Schedule Autonomous ADK Agents on GCP with Cloud Scheduler
- Personal software factories are a waste of time
- Modernizing perimeter security: Scalable perimeters with VPC Service Controls
- Stacked PRs: what they are and how to run CI on a stack
- What requirements don’t you have?
- Step by Step guide: Build a Voice Agent That Never Goes Silent using ADK

