↵ select ↓ ↑ navigate esc close

Seroter's Daily Reading: Daily Reading List – October 15, 2026 (#889)

Seroter's Daily Reading ·

Listen: https://blossom.buildtall.systems/4cca581e846aded1b842d81879f25f1384941487a216abae56592d6f21e134ec.mp3

Source: https://seroter.com/2026/10/15/daily-reading-list-october-15-2026-889/


Welcome to Seroter's Daily Reading. Today's episode covers the Daily Reading List for October 15, 2026, number 889. Richard Seroter opens by noting that many of today's items are sobering looks at how we rethink our work, asking where we need to double down on quality or knowledge even as we surrender the coding portion of software delivery.

The first article is "nobody should type code by hand anymore. here’s what’s left" by Geoffrey Huntley. Seroter says this post is absolutely stuffed with insightful points and recommends taking the time to go through it. Huntley argues there's no place left for a software engineer who types code by hand; the models stopped being the constraint a long time ago, and what remains is vision, verification, and agency. The post recounts a four-part conversation with Josh Wulf about loop engineering. Key points include the travelator of tech moving on, with people who haven't stepped on it being left behind; the idea that subsidies from VC-backed model providers are effectively a free university education; and the shift toward acquiring 'molecules' of well-jelled teams rather than individual engineers. Huntley also stresses verification: he puts the entire system under test using Nix and works at Antithesis, which runs software under worst-case conditions with fault injection and property-based testing. He argues that if human code review were sufficient to stop bugs, we'd never have defects, and that ownership and accountability matter more than whether AI wrote the code.

Next is "5 things every EM must read/listen/watch" by Anton Zaides. Seroter's advice is not to just have your agent summarize everything for you; keep reading books or doing deep digestion of online content. Zaides curates a timeless shortlist of five resources in each category: books, articles, newsletters, and podcast episodes. The books range from "Become an Effective Software Engineering Manager" by James Stanier to classics like "Peopleware" and "Extreme Programming Explained". The articles include Joel Spolsky's "The Econ 101 Management Method", Paul Graham's "Maker's Schedule, Manager's Schedule", and Michael Lopp's "The Update, the Vent, and the Disaster". Newsletters highlighted include The Pragmatic Engineer and Stay SaaSy. Podcast episodes feature Netflix's culture of excellence and a talk on shipping 2,500 pull requests. The article argues that deep reading and listening still matter even in an AI-driven world, because they build context and judgment.

Then we have "Python vs Go: A Practical Comparison for Developers" by Dominika Stankiewicz on the JetBrains Go blog. Seroter remarks that he's not sure how much longer we'll have clear distinctions between developer populations, but for now, different people gravitate to different work. The article draws on the 2026 Developer Ecosystem Survey and interviews with developers who moved from Python to Go. Python favors expressive code and rapid iteration; Go favors explicit, standardized code that's easy to maintain across teams. Go excels in raw performance and concurrency, and is widely used in cloud infrastructure, while Python remains stronger for machine learning, data science, and scientific computing. Developers who switched often cited better concurrency and production performance, but they rarely abandon Python entirely; most teams use both, with Go for services and infrastructure and Python for AI and data workloads.

The next article's title is

66% of billion-dollar companies leave critical bugs unpatched — the part the AI bug-hunting hype leaves out.

Seroter's take is blunt: if we don't change ops or our approach during development, we're just pushing out more software we can't actually maintain. The title itself is a sobering statistic, and the piece argues that while AI bug-hunting tools generate excitement, they don't address the fundamental operational problem: even large, well-funded companies fail to patch known critical vulnerabilities. That gap undermines the promise of AI-powered security.

Seroter flags a blog called

Your widget tree is already a list of options: where Jev fits in a Flutter project.

He says to watch and see where decision models start popping up in applications, or when any model is still overkill for the task. The title suggests it explores how a Flutter widget tree can be treated as a list of options and where a tool called Jev fits in. Unfortunately the full article couldn't be retrieved, so we'll have to rely on Seroter's pointer that decision models are becoming relevant in user interface design.

Next,

Can AI review agents take humans out of code review?

from RDEL. Seroter notes that agents are getting better at finding bugs, but it's interesting that humans find different bugs than agents do. The article describes a benchmark of ten models on 1,800 review tasks. The best agent caught 71.9% of known bugs, up from 47.7% five months earlier, while human reviewers caught about half. Together they reached 82.1%. Humans were better at maintainability issues; agents were better at severe and reliability bugs. Detection dropped sharply on large, mixed, or bug-fix pull requests. On proprietary codebases, agent performance dropped by up to 25.5% because context wasn't in the diff. The authors suggest routing review effort by PR shape, using cheaper agents for small changes, and keeping humans in the loop for larger ones.

Seroter also highlights

Stop Defaulting to “Medium”: Optimizing Gemini 4 Argon and 3.8 Flash Effort Budgets in Antigravity.

He says yes, Daniel's right: we shouldn't just default to a medium thinking level with our models when low will often do just fine. The title indicates it's about adjusting effort budgets for Gemini models in Google's Antigravity environment, and Seroter agrees with the author's push to stop over-provisioning model reasoning.

Then there's

The Vanishing Engineering Signal in AI Hackathons.

Seroter finds this worrisome, especially because it isn't just a hackathon thing—it's happening in real environments everywhere. The title suggests AI is making it hard to see actual engineering skill in hackathon projects, and Seroter connects that to broader industry trends.

Next up is "When code is cheap, judgement becomes the job" by Swizec Teller. Seroter's take is that we're all doing higher order work, but that requires good judgement and not letting up on our responsibilities. Teller describes his experience at Plasmidsaurus, a company that ships many times a day with heavy AI coding. Accountability comes first: you merge code, you own it, regardless of whether AI wrote it. The biggest impact of agentic development is on the tail end—fixing long-tail bugs and operational friction. But starting got easy while finishing remains hard; there's a trap of opening too many pull requests. Code review is now the highest leverage for senior talent because agents lack judgment and business context. Teller also argues that code quality is money: better file structure reduced token costs by 83% in one experiment. He recommends turning manual review rules into deterministic linters and always reading the code.

The HBR article "Team Dynamics Weaken When Employees Turn to AI instead of Colleagues" is also sobering. Seroter says that when we displace interactions with our teammates by going to AI, we cause problems in trust and coordination. The article draws on the concept of transactive memory systems: teams work because people know who knows what. When employees ask an AI instead of a colleague, that shared map of expertise erodes, weakening the team's ability to coordinate and trust one another. The authors argue that organizations need to be intentional about preserving human-to-human knowledge sharing even as AI tools become ubiquitous.

Finally, "Temporal Serverless Workers on Cloud Run: Scale workers ahead of demand" covers a new integration. Seroter notes Temporal has been around a long time but is super hot lately, and their orchestration plays well right now. The Google Cloud blog explains that Cloud Run worker pools are built for pull-based background work, and now Temporal Cloud can autoscale those pools based on task queue backlog. This eliminates the need for Kubernetes clusters, custom autoscalers, and idle compute. Workers scale to zero when there's no work, and Temporal uses versioning to keep long-running workflows on the build they started with. Use cases include autoscaled agentic workers, long-running entity workflows, and bursty batch jobs.

The through-line today is clear: AI is changing the mechanics of software delivery, but the human parts—judgment, verification, relationships, and operational discipline—still determine whether we succeed. Seroter's reading list reminds us to keep questioning defaults, keep reading deeply, and keep owning the outcomes.

  1. Daily Reading List – October 15, 2026 (#889)
  2. nobody should type code by hand anymore. here’s what’s left
  3. 5 things every EM must read/listen/watch
  4. Python vs Go: A Practical Comparison for Developers
  5. 66% of billion-dollar companies leave critical bugs unpatched — the part the AI bug-hunting hype leaves out
  6. Your widget tree is already a list of options: where Jev fits in a Flutter project
  7. Can AI review agents take humans out of code review?
  8. Stop Defaulting to “Medium”: Optimizing Gemini 4 Argon and 3.8 Flash Effort Budgets in Antigravity
  9. The Vanishing Engineering Signal in AI Hackathons
  10. When code is cheap, judgement becomes the job
  11. Team Dynamics Weaken When Employees Turn to AI instead of Colleagues
  12. Temporal Serverless Workers on Cloud Run: Scale workers ahead of demand