Seroter's Daily Reading — #835 (July 29, 2026) · Seroter's Daily Reading

Listen: https://blossom.buildtall.systems/dbcd6153abb047f2d285d22c8e4fbdda069a9f04304a75bb2cca33c8d79bd8bd.mpga

Seroter's Daily Reading, episode 835, July 29, 2026.

Let's dive in.

Starting with a piece from the PostHog newsletter on How much can you delegate to agents?. The piece asks a deceptively simple question: how much can you actually delegate to your agents? The conventional wisdom seems to be that smarter models mean you can trust agents more. But the author flips that on its head and says, no, it's not about the model at all — it's about the task. Specifically, two questions set the ceiling. First: is it easy to check the agent's work? If you have deterministic checks like tests, great. If it requires subjective taste, that's harder. Second: is it cheap to undo a mistake? Can you roll back if the agent messes up badly? These two axes map out four autonomy levels: zero is the agent as a simple assistant, like autocomplete — you check everything. Level one is human in the loop — the agent does the work but you review it before anything merges. Level two is delegation — the agent runs, you have checks, but the blast radius is limited. And level three is self-driving mode — the agent can run freely because checking is trivial and rolling back is cheap. The most interesting takeaway for me is that you can engineer your way up the ladder. If a task is currently hard to check, you might be able to write a custom skill or define a measurable goal that makes it checkable. That shifts the task into a higher autonomy tier. PostHog is already running scheduled agents they call Scouts — agents that monitor signals and draft PRs autonomously. That's a practical example of level three thinking. Good piece by Jina Yoon.

Next up, a Medium post on Eval Is Evil: How to Safely Execute Untrusted AI Code with Cloud Run sandboxes and ADK. Seroter flagged this as relevant for anyone running injected scripts in their app — fun for demos, dangerous in production. The piece walks through using Cloud Run's sandboxing capabilities alongside the Agent Development Kit to safely execute code you don't fully trust. Without the full article content available, the title tells you the core argument: eval is evil. Meaning, if you're evaluating or running arbitrary code, you need isolation, not just trust. Cloud Run's sandbox environment gives you that container-level separation. Good context for anyone building agentic systems that might receive or generate executable payloads.

Third piece today is a longer essay from Steve Magness on We Killed Reading the Same Way We Caused the Obesity Epidemic — and it's framed as a mirror to the obesity epidemic. His argument is that we've rigged the environment against reading the same way we rigged it against healthy eating. We flooded kids with smartphones and social media, stripped out recess and unstructured time, changed how reading is taught to favor cueing and guessing over actual phonics, and then tested kids on fragments instead of whole books. The result is that fewer than half of US adults read a book in a given year, sustained attention has dropped from two and a half minutes to 47 seconds, and the share of teenagers who never read for fun has quadrupled since 1984. What I found most interesting is his prescription. He doesn't go all scold about screen time. Instead he says, start with the phone, sure, but also kill the elitism. Read what you enjoy. Manga, romance, Goosebumps, doesn't matter. And you don't have to finish every book. Give it fifty pages, and if it's not pulling you in, quit and move on. He's essentially applying the same advice you'd give someone getting into exercise — make it enjoyable, build the habit, and let the habit evolve. There's also a good point about modeling. Kids do what adults actually do, not what adults say they should do. If you're scrolling in bed, your kids will scroll too. Silent book clubs are having a moment, by the way. They grew 31% on Eventbrite last year. That fits the pattern: people want to read, they just need a structure and a little accountability.

Moving on to a blog post from Eduardo Bellani on Why care about programming languages. Seroter highlighted this one because it cuts against the grain of a common feeling these days — why bother learning the deep details of a language when AI can write code in anything on demand? Bellani's answer is that a language's worth comes from the ideas it embodies, not its syntax. For example, Rust's borrow checker teaches you to think about ownership and lifetimes — concepts that reshape how you reason about resource management everywhere, even in languages that handle it for you. Haskell's typeclasses teach principled polymorphism. SQL teaches relational theory and declarative data thinking. Prolog teaches logic-based problem solving. Each of these ideas expands your mental toolkit in ways that transfer far beyond the language itself. Bellani argues this becomes more important, not less, in the AI age. Because when an AI generates code, you still need to know whether it's good. You need to evaluate the abstractions, catch the subtle bugs, and architect systems that stay maintainable. The people who just prompt aren't engineers. They're something else.

From the Google Cloud blog again, a piece on Automated pull request reviews with Gemini Managed Agents. This is a concrete example of using Google's fully managed agent infrastructure to automate code review. Seroter called it a nice example of using those managed agents. The idea is that you can have a Gemini agent sit in your PR pipeline, read the diff, understand the context, and leave structured comments — all without needing to manage the underlying infrastructure yourself. Managed agents handle the orchestration so you can focus on the review logic. This ties back to that PostHog piece nicely — code review is a perfect level two autonomy task. It's relatively easy to check — you can run tests, have linters, look for patterns — and the blast radius of a bad review comment is low. So it's a good candidate for agent delegation.

Next up, a piece from Dave's Research on Gameplay Before Strategy. This one's for the product and leadership crowd. Dave's argument is that a lot of teams and leaders get seduced by grand strategy — they want to talk about how they're going to win, what their operating model looks like, the big vision — while the actual gameplay is broken. They're not sure how to make good moves, they don't have a feel for how the game is unfolding, and they're leaking energy into poor decisions. His framing is borrowed from Wardley Mapping, where the first phase of strategic doctrine is stopping self-destructive behavior. Good leaders, he says, start by making sure the team can play one good move right now. Not a grand vision, just one well-executed move. Only once the team stops making unforced errors and builds confidence does it make sense to look at the larger field and harvest patterns for scaling. Strategy, he argues, emerges from gameplay. You can't impose it top-down without the feel for how the game actually works. I love this framing because it maps directly to how good engineering teams operate too. Before you decide on your architecture roadmap, you need to have shipped a few things well and learned how the system responds.

From VentureBeat, an interview with Target's SVP on Target SVP says its real AI moat isn't the models — it's everything built around them. Her argument is that the AI moat isn't the models — it's everything built around them. The models are important, she says, but they're not sufficient for competitive advantage. What matters is the discipline of deciding whether you even need an agent in the first place, what type of agent, what triggers it, what it has access to, and how you'll monitor it over time. Target structures agent autonomy as a four-level ladder. New agents start low and earn more autonomy as they prove themselves — similar to how humans earn trust by demonstrating competence over time. Agents that drift get taken out of service. There's a story in the piece about a digital twin that predicted men's shorts inventory for three stores and found that one needed six to seven times more stock than the others. The reason? It was two miles from the beach and the other two were ten to twelve miles inland. The analysts thought that couldn't be right, but they let the recommendation stand and it sold through. That's when an agent earns more autonomy. Mc Feeney also makes the point that this requires a cultural shift. Builders are now observing agents building, while also coaching humans who are observing agents building. It's a new skill set entirely.

Last piece today from the Google Cloud blog on Automate your agent development lifecycle using any coding agent. The pitch here is that you can build, deploy, govern, evaluate, and share agents without leaving your coding harness. The Agents CLI and the Agent Development Kit together let you handle the whole lifecycle in plain English from within your development environment. An example in the piece: an analyst asks, in their normal app, what materially changed for their semiconductor watch list this week, and which company announcements aren't backed by an SEC filing. The agent returns a grounded, cited answer with a flag on the unsupported claims. This is a governed, published enterprise asset — not a demo. The point is that the coding agent becomes the control plane for the whole agent lifecycle. You never have to context-switch to a different UI or mental model. The same harness that writes code also deploys and manages agents. That's a compelling vision for developer experience.

A few threads tie these together. The PostHog piece, the Target interview, and the Google Cloud lifecycle piece all circle the same theme from different angles: autonomy isn't a switch you flip, it's a spectrum you earn. Start conservative, build trust through results, and level up over time. Bellani's piece reminds us that understanding the ideas underneath our tools matters more as those tools get smarter. And Magness's essay is a useful reminder that the same forces reshaping how we work are also reshaping how we think — and that environment and habit design are the levers we keep underestimating.

That's the reading for July 29, 2026. We'll see you next time.

No Nostr signer detected