Seroter's Daily Reading — #757 (April 6, 2026) — Seroter's Daily Reading

Listen: https://blossom.nostr.xyz/8192a39b1862111b21236247f818f27cd34065aa7d21e77b071dc5a7ab23109f.mpga

Seroter's Daily Reading, Episode 757. April 6, 2026. I'm Rob.

Richard Seroter leads off today's list with a callout that I think is worth sitting with: "Lots of hard truth in today's reading list. A lot of people came out hot from the Easter weekend. Dig in." So let's dig in.

First up, a piece from Terrible Software titled "Good Taste" Is Just Experience. The framing here is that you see a lot of people lately saying taste is the ultimate differentiator in the age of AI. That taste is what AI can't replace. And the author doesn't fully disagree, but he thinks the framing is wrong. When people say "taste," they actually mean experience. Pattern recognition built up over years of doing the work. The problem is that calling it "taste" makes it sound like a gift you either have or you don't, rather than a skill you develop. The author, who has spent 16 years in engineering management, says his great taste in management is really just pattern recognition from hundreds of one-on-ones, hard conversations, and projects that went right or wrong. His advice to junior developers feeling intimidated by the taste talk: show up, keep doing the work, and the taste will come. "You need reps" is a much better message than "you either have it or you don't."

Next, Harvard Business Review with an article that is basically a checklist for why your AI initiatives are probably going to fail: To Succeed with AI, You've Got to Nail the Basics. The author's core argument is that companies fall into a trap of magical thinking, believing that layering AI on top of their existing processes will hide their past sins. They assume their data is better than average, that a human in the loop will catch any problems, and that AI is basically free money. It's not. The author, who has 35 years of advisory experience, maps five timeless basics of quality management onto AI readiness: customer centricity, a focus on process, acting on facts, continuous improvement, and the recognition that quality happens through people. His point is that if you don't have those fundamentals in place, no amount of AI window dressing is going to save you. The most memorable example in the piece: a manager named Sarah who asks Gemini to write a performance review for an analyst who needs to be more assertive. Gemini produces three polished paragraphs. Tim, the analyst, gets nothing useful. HR notices the review doesn't align with corporate feedback policy. Sarah ticks a box and saves a few minutes, but both customers of her work are unhappy. AI cannot, on its own, know who your customers are and sort out their needs.

Okay, on to developer tooling. Mandie Quartly on Medium has a practical walkthrough: The Surprisingly Simple Way to Create an A2A Agent with ADK, Deploy on Cloud Run, and Register with Gemini Enterprise. A2A stands for Agent-to-Agent, and there's a protocol for it. The piece shows how Google's Agent Development Kit makes it surprisingly straightforward to expose a local agent using a function called to_a2a. That one line of code automatically generates an agent card, which is essentially the metadata that lets other agents discover and communicate with yours. She walks through local testing with uvicorn, deploying to Cloud Run with a single adk deploy command, and then registering the agent in Gemini Enterprise so end users can actually interact with it. The takeaway is that surfacing agents for enterprise use is getting much easier, and the to_a2a function handles a lot of the boilerplate that used to require hand-rolling.

Now, The New Stack with a piece that I think is the most significant product story of this entire reading list: Cursor's $2 billion bet: The IDE is now a fallback, not the default. Cursor shipped version 3 this week, built under the codename Glass, and it fundamentally redesigns the product surface. The agent management console is now the primary interface. The traditional code editor is pushed to secondary status. The prompt box moves to where the file tree used to be. This is a company that crossed two billion dollars in annualized revenue in February, doubling in three months, and they're completely rebuilding their UI around agents. The piece walks through the features: multi-repo workspaces by default, cloud handoff so you can move a running agent session from your laptop to the cloud mid-task and pull it back when you want full local control, unified sidebar showing agents from every surface including mobile, the web client, Slack, GitHub, and Linear. The author, Janakiram MSV, draws an analogy to cloud infrastructure: AWS's management console became the control plane, and SSH became the debugging tool you reach for occasionally. Cursor 3 treats agents as the control plane, and the IDE as SSH. The structural implication is that the VS Code moat is drying up. When the primary interaction surface shifts from editing files to managing agents, traditional IDE competitive advantages in code intelligence and refactoring tools matter less. And this comes at a moment when GitHub is struggling with its own relevance, which we'll get to.

From dbreunig.com, an analysis piece: How Claude Code Builds a System Prompt. The author is a fan of reading system prompts, and last week the source code for Claude Code was accidentally leaked. That gave us, for the first time, a clear view of how the system prompt is actually assembled dynamically. The piece includes a visualization showing each component: some are always included, some are conditional, some have variations depending on context. What's striking is the complexity. There are components for output style, system rules, tool usage guidelines, session guidance for sub-agents, skills, git status snapshots, language settings, and more. Many of these are conditional, so the final system prompt changes based on things like whether the user is an Anthropic employee, whether the repo is a git worktree, whether MCP servers are connected, whether memory is configured. The author notes that the system prompt is just one part of the context assembly. Tool definitions involve around 50 tools with their own conditional logic. User content includes CLAUDE.md files. Conversation history has compaction and summarization logic. Skills get appended each turn. The takeaway is that agents are much more than models. Context engineering is the critical layer.

On to VentureBeat with news that landed this week: Anthropic cuts off the ability to use Claude subscriptions with OpenClaw and third-party AI agents. Starting April 4th, Claude Pro and Max subscribers can no longer use their plans to power third-party agents. The reason, according to Anthropic's head of Claude Code: third-party services aren't optimized for the prompt cache hit rates that Anthropic's own tools exploit. Put simply, OpenClaw and similar tools waste a lot of compute compared to Claude Code, and Anthropic wants to prioritize its own products and API customers. Anthropic is offering affected subscribers a one-time credit and discounts on extra usage bundles, but the writing is on the wall. The open source harness ecosystem built around Claude is being squeezed. OpenClaw's creator, who was recently hired by OpenAI, was skeptical about the timing, noting that Anthropic had recently added some of the same features that made OpenClaw popular directly into Claude Code. The author's take is blunt: the era of subsidized unlimited compute for third-party automation is over. For average users, experience remains unchanged. For power users running autonomous workflows, the bell has tolled.

Now, two Go pieces back to back from dev.to that are both excellent and clearly by the same author. First: Stop Writing Go Like It's Java: 5 Patterns You Need to Unlearn. The author's premise is that developers coming from Java, Python, or TypeScript picked up Go syntax quickly, code compiles, tests pass, but it's still wrong in ways that bite at 3 AM. The first mistake: defining interfaces before you need them. In Java you interface everything upfront because dependency injection frameworks expect it. In Go, the idiom is accept interfaces, return structs. Define the interface at the call site, in the package that uses the dependency, not the one that provides it. Second mistake: losing the error chain. Using %v instead of %w in fmt.Errorf destroys the ability of downstream code to use errors.Is or errors.As for programmatic error checking. Third: reaching for channels when a mutex will do. The famous Go proverb about not communicating by sharing memory gets misread as always use channels, but if you're protecting shared state, a mutex or atomic operations are the right tool. Fourth: using struct embedding to simulate inheritance. It looks like inheritance, but there's no override, no super, no virtual dispatch. Fifth: designing structs that fight the zero value. In Java every object needs a constructor, but Go's zero value is often useful. Design your structs to have sensible defaults at zero. The author's bottom line: the fastest way to write good Go is to forget what good code looks like in Java for a while.

Second Go piece, same author: Go Project Structure for Humans: No, You Don't Need 15 Directories. The key insight is that the Go team has never published an official project structure. That's by design. The author's advice: start with main.go, write your code, and when you feel actual pain when you can't find things, when packages are getting too big, when you need to share code between binaries then restructure. Pain is the signal. Not anxiety about doing it wrong. The piece lays out three stages. Single-file projects for tools and prototypes. Growing projects that split by domain, not by type. He specifically calls out the anti-pattern of organizing by models, handlers, services, repositories where every feature touches every directory. The better approach is user package, order package, notification package, where each package owns its entire domain. Stage three is multiple binaries, which is when cmd/ earns its place. He also has a sharp section on the utils trap: utils and helpers directories are code smells. Put functions where they belong, next to the code that uses them.

From the Pragmatic Engineer newsletter, Gergely Orosz with a pointed piece: The Pulse: is GitHub still best for AI-native development? The opening data point is striking. GitHub's reliability has dropped to one nine of availability. That's around 10% downtime in a given month. Third-party tracking shows GitHub had issues on roughly 3 out of every 30 days recently. Meanwhile, load from Claude Code has increased sixfold in three months. GitHub's CTO wrote a post addressing the outages, attributing them to database saturation, failover issues, and Redis cluster failures. But the piece makes the case that GitHub has deeper problems. No CEO since Thomas Dohmke stepped down and Microsoft didn't backfill the role. Copilot, which was the first massively successful AI product in 2021, has been overtaken by Claude Code and is soon to be overtaken by Cursor. GitHub has no North Star for AI-native development. Mitchell Hashimoto, founder of Ghostty, weighed in with advice he would give if he were in charge: establish a North Star around being critical infrastructure for agentic code lifecycles, fire everyone working on Copilot and shut it down, buy Pierre Computer, a startup that claims to handle fifteen thousand repos per minute compared to GitHub's roughly 230. His conclusion: GitHub should be a platform and not try to be an agent itself.

Moving on, a piece on unoffendability from Robert Glazer's Friday Forward: No Offense. Glazer opens with a personal story about giving a presentation on personal values that one audience member hated, apparently going in looking to be offended and unsurprisingly finding exactly what they were looking for. He says their feedback cost them more than it cost him. His broader point is that our culture has given rise to the concept of microaggressions, and while the concept has value for identifying repeated hostile patterns, a heavy focus on it encourages people to dismiss intent as irrelevant and label ambiguous behavior as aggressive by default. This fosters suspicion rather than empathy. When you go through the world expecting aggression in ordinary moments, the world seems overwhelmingly hostile, and the person most damaged by that posture isn't the people around you. It's you. His prescription: assume positive intent, listen before reacting, approach disagreement as a chance to learn, and remember you're better off knowing what someone actually thinks even if it's hard to hear. He closes with a Warren Buffett quote: you will continue to suffer if you have an emotional reaction to everything that is said to you.

From isolveproblems.substack, a bombshell: How Microsoft Vaporized a Trillion Dollars. This is the first in a series written by a former Azure Core engineer who rejoined in May 2023. His opening anecdote is remarkable. On his first day, he walked into a planning meeting and found an entire 122-person org seriously contemplating porting Windows to Linux to support their existing VM management agents on a tiny ARM SoC with 4 kilobytes of dual-ported memory. Meanwhile, they had identified 173 agents as candidates for porting to this tiny chip, and nobody at Microsoft could articulate why 173 agents were needed to manage a single Azure node, what they all did, or how they interacted. That stack was orchestrating VMs running Claude on Azure, what was left of OpenAI's APIs, SharePoint Online, government clouds. The author describes what followed: his warnings to the CEO, the Board, and the Cloud plus AI EVP, their total silence, the quasi-loss of OpenAI, the breach of trust with the US government as publicly stated by the Secretary of Defense, wasted engineering efforts, a Rust mandate, his stint on the OpenAI bare-metal team, escort sessions from China, and delayed features publicly implied as shipping since 2023. This is billed as the first of a series, and Richard says it's multi-part written by a former employee. Wild stuff.

From InfoWorld, Matt Turck with an article that's going to generate some discussion: Multi-agent AI is the new microservices. The argument is that we are already over-engineering multi-agent systems when a single agent with good tools would often suffice. The piece cites guidance from OpenAI, Microsoft, and Google, all of which recommend maximizing a single agent's capabilities first before jumping to multi-agent frameworks. Microsoft is particularly blunt: if the use case doesn't clearly cross security or compliance boundaries or involve multiple teams, start with a single-agent prototype. Even planner, reviewer, and executor roles don't automatically justify multiple agents, because one agent can often emulate those roles through persona switching and conditional prompting. Microsoft's additional point that deserves extra attention: many apparent scale problems stem from retrieval design, not architecture. Fix chunking, indexing, reranking, and prompt structure before adding more agents. The author draws the microservices comparison explicitly: complexity doesn't vanish when you decompose a system. It relocates. Back then it moved into the network. Now it threatens to move into hand-offs, prompts, arbitration, and agent state.

From a16z, Joe Schmidt and David Haber: Et Tu, Agent? Did You Install the Backdoor?. This one is about supply chain security in the AI era. The hook is that Axios, one of the most popular npm packages, was compromised. An attacker didn't change a single line of Axios source code. They compromised a maintainer's account, added one new dependency to the package manifest, and published an update. That dependency, a brand-new package registered hours earlier called plain-crypto-js, ran a script on install that detected your OS, downloaded a remote access trojan tailored to your machine, executed it, and deleted itself. By the time you looked in node_modules, it was gone. The malware had already phoned home. And here's the critical point: modern security tooling looks for the wrong things. Most software composition analysis tools work by checking dependencies against a database of known vulnerabilities. But a deliberately planted backdoor has no CVE. npm audit on the compromised Axios version would have returned clean because the malware self-destructed. The Axios attack was caught by Socket, which analyzes what code actually does rather than matching against known CVEs. They detected it within six minutes of publication, sixteen minutes before the first compromised version was even published. But the average time to detect a supply chain breach across the industry is 267 days. The piece also covers the TeamPCP campaign, which cascaded from GitHub Actions to Docker Hub, npm, PyPI, and the VS Code extension marketplace in eight days with just one stolen token. The conclusion: we are building a world where machines write the code, machines choose the dependencies, and machines ship the updates. If we don't secure the supply chain, the AI agents are cooked.

And finally, something completely different. NASA's Artemis II crew just flew farther away from Earth than anyone in history. (Engadget) The four astronauts, Reid Wiseman, Victor Glover, Christina Koch, and Jeremy Hansen from the Canadian Space Agency, have now gone more than 250,000 miles from Earth, breaking the 1970 record set by Apollo 13's crew by about 4,000 miles. They crossed that threshold while circling the Moon, and Commander Wiseman suggested naming a lunar crater after the spacecraft itself. They're conducting a lengthy flyby that should provide clear images of the Moon's far side that have never been seen by humans. Orion is now on its crawl back to Earth, with a planned splashdown in the Pacific near San Diego on April 10th. Astronaut Victor Glover delivered an Easter message from orbit calling Earth an oasis and saying humanity is special in all of this emptiness.

That's the full list for episode 757. Hard truths, as Richard put it. The IDE is getting demoted, GitHub is wobbling, Anthropic is locking down its ecosystem, supply chain attacks are accelerating faster than tools can detect them, and the multi-agent future may be over-engineered before it even arrives. But hey, humanity just flew farther from Earth than it ever has before. So there's that. I'm Rob. Catch you next time.

Articles Covered

"Good Taste" Is Just Experience — Terrible Software — https://terriblesoftware.org/2026/03/27/good-taste-is-just-experience
To Succeed with AI, You've Got to Nail the Basics — Harvard Business Review — https://hbr.org/2026/04/to-succeed-with-ai-youve-got-to-nail-the-basics
The Surprisingly Simple Way to Create an A2A Agent with ADK... — Medium / Google Cloud — https://medium.com/google-cloud/surprisingly-simple-a2a-agents-with-adk-using-to-a2a-deploy-to-cloud-run-and-gemini-enterprise-e815bdef4a32
Cursor's $2 billion bet: The IDE is now a fallback, not the default — The New Stack — https://thenewstack.io/cursor-3-demotes-ide/
How Claude Code Builds a System Prompt — dbreunig.com — https://www.dbreunig.com/2026/04/04/how-claude-code-builds-a-system-prompt.html
Anthropic cuts off the ability to use Claude subscriptions with OpenClaw... — VentureBeat — https://venturebeat.com/technology/anthropic-cuts-off-the-ability-to-use-claude-subscriptions-with-openclaw-and
Stop Writing Go Like It's Java: 5 Patterns You Need to Unlearn — dev.to — https://dev.to/gabrielanhaia/stop-writing-go-like-its-java-5-patterns-you-need-to-unlearn-4l2a
Go Project Structure for Humans: No, You Don't Need 15 Directories — dev.to — https://dev.to/gabrielanhaia/go-project-structure-for-humans-no-you-dont-need-15-directories-2k36
The Pulse: is GitHub still best for AI-native development? — Pragmatic Engineer — https://blog.pragmaticengineer.com/the-pulse-is-github-still-best-for-ai-native-development/
No Offense — Robert Glazer / Friday Forward — https://robertglazer.substack.com/p/friday-forward-no-offense-530
How Microsoft Vaporized a Trillion Dollars — isolveproblems.substack — https://isolveproblems.substack.com/p/how-microsoft-vaporized-a-trillion
Multi-agent AI is the new microservices — InfoWorld — https://www.infoworld.com/article/4154335/multi-agent-ai-is-the-new-microservices.html
Et Tu, Agent? Did You Install the Backdoor? — a16z — https://www.a16z.news/p/et-tu-agent-did-you-install-the-backdoor
NASA's Artemis II crew just flew farther away from Earth than anyone ever has — Engadget — https://www.engadget.com/science/space/nasas-artemis-ii-crew-just-flew-farther-away-from-earth-than-anyone-ever-has-before-180259867.html

Source: https://seroter.com/2026/04/06/daily-reading-list-april-6-2026-757/