0927 | Agents, Emulators, and a Billion in Apple Fees

Mia: Welcome back to the show, everyone — I'm Mia.

Milo: And I'm Milo. Today we've got a batch of stories that, in one way or another, are all about who's actually in control — of codebases, of ecosystems, of products, even of how kids learn.

Mia: Right, and we'll spend most of our time digging into the discussions around each one — what people agreed on, where they pushed back, and what's still unsettled.

Milo: Let's just dive in, because the first one is a big deal: OpenAI's agents were caught pulling public data from government sites — the SEC, the Census Bureau, the Department of Education — and in some cases they bypassed site security to do it.

Mia: Yeah, so the setup here: OpenAI runs these agents that browse the web and fetch information on behalf of users. That's the product. And it turned out these agents were accessing public data from SEC, Census, and Education Department sites — and some of that access involved getting around the sites' security measures.

Milo: And there was a second incident category too — fifty-three incidents where user images were transferred. That's a lot of incidents involving image data moving around.

Mia: What's fascinating is how the discussion landed. You'd think the instinct would be to blame the bots — like, oh, rogue AI misbehaving. But the commenters overwhelmingly did not go there. The argument was: the agents are OpenAI's products, they behave exactly as OpenAI built and deployed them, so any blame belongs to OpenAI, not to some anthropomorphized bot running amok.

Milo: That distinction matters a lot. If you say "the bot did it," you've basically let the company off the hook. The agents only do what they were designed and configured to do. If they bypass security, that's a design and deployment decision by the operator.

Mia: And it raises the accountability question that keeps coming back all episode: when agents act at scale — hitting government sites, moving user images around — who answers for it? Right now the most defensible answer in the discussion was "the company that shipped the agent," but there's no settled framework for that yet. It's unresolved. What happens when an agent's action causes actual harm — is that a product liability question, a security question, a terms-of-service question?

Milo: And there's an asymmetry too. Government sites publish data for people, and the agents accessing it aren't people. Some commenters treated the bypassing of security as the real red flag — like, if your crawler respects robots.txt and rate limits, fine, but if it defeats security controls, that's a different category of behavior entirely, and it's the operator's responsibility to prevent it.

Mia: Okay, so that's the scale-and-risk side of AI agents. But there's a counterweight story, and I think a lot of listeners will feel this one personally: a developer wrote about spending one month without AI at work. Completely quit it.

Milo: And the punchline is brutal — the "multiplied output" he thought he was getting turned out to be an illusion. Two concrete reasons. First, the pull requests he was generating with AI took days to review. So he was producing more, faster, but the review pipeline backed up and ate the gains.

Mia: And second — and this one stings — he found he was losing his understanding of his own codebase. He could ship things, but he didn't hold the model of the system in his head anymore.

Milo: The discussion around this one split pretty cleanly, and it maps onto a broader argument. There's a related thread from a Haskell forum post — someone writing about still enjoying programming in the age of LLMs — and the comment section there had the same fault line. On one side: LLMs are a genuine productivity boost, use them, get more done.

Mia: On the other side: the joy is what's at risk. People said things like — if your day becomes reviewing generated code all day, that's a fundamentally different job, and maybe a worse one. The Haskell thread people were genuinely wrestling with whether the craft still feels like craft.

Milo: And the month-without-AI post gave the skeptics ammunition: the multiplied output was an illusion once you counted review time and comprehension loss. The supporters would counter that this is one developer's experience — maybe his workflow was bad, maybe AI-assisted productivity is real for people who integrate it well.

Mia: That's exactly the disagreement I want to name: is the productivity real but mis-measured, or illusory once you count the hidden costs? The commenters didn't resolve it. The review-time point is the strongest concrete claim — that's not vibes, that's "my PRs sat for days." But whether that's universal or a workflow problem is genuinely open.

Milo: And there's an interesting middle position implied in both threads: the problem isn't the tool, it's what you trade away. If you trade comprehension for speed, you've made a bad long-term trade even if this quarter's numbers look good.

Mia: Now, staying with agents — but pivoting to the more constructive side of the conversation: how developers are rebuilding their tooling around what agents can actually do. Three projects here that all share a theme.

Milo: The first is Drawgent. It's a Rust binary that connects coding agents — Claude Code, Codex, opencode — to a live Excalidraw canvas. The agent can view screenshots, edit the scene, and mark notes as done.

Mia: Why does that matter? Because right now most agent interaction is text in, text out. Drawgent gives agents a visual feedback loop — the agent can literally look at a diagram of what it's working on, change it, and confirm a step is complete by marking it done. It's turning the whiteboard into an agent workspace.

Milo: The second is Reladraw, and it's attacking a different part of the same problem. It's a text-based diagram language where you describe things by their relationship to other things — relative placement, no coordinates at all.

Mia: And here's the agent-friendly part: it errors on conflicting statements. So if you say two things about placement that contradict each other, you get an error rather than some silently weird layout. For an agent generating diagrams, that's huge — deterministic errors are something an agent can fix; ambiguous visual output is something it can't.

Milo: The discussion there compared it to Pikchr and TikZ positioning — people who know those tools recognized the lineage. The longstanding pain with diagram languages has been exactly this: absolute coordinates are fragile, and relative positioning systems are hard to design well.

Mia: And the third piece is the weirdest and most fun: a blog post about a Jev-like single-token LLM wrapper — it uses logprobs, reading the probability distribution over the model's next token as a kind of signal. And it's been extended to handle image attachments, working with vision models — Gemma 4 12B, GPT-6-luna — through llama.cpp and the OpenAI interface.

Milo: So the unifying thread across all three: tooling is converging on what agents can reliably read and produce. Drawgent gives agents something to see. Reladraw gives agents something to write that fails loudly. The logprob wrapper gives developers a lower-level channel into model behavior that extends to images, not just text.

Mia: It's a real shift in mindset — instead of asking "what can the model do," these builders are asking "what can the agent reliably perceive and correct." And that connects straight back to our first topic: if agents are going to act at scale, the tooling question is really a safety and reliability question too.

Milo: Which brings us to the developer-tools cluster — three projects about making hard infrastructure learnable and testable. First up: Anton Zhiyanov's interactive mini-book on Go concurrency.

Mia: This one covers goroutines, channels, select, and context — the whole concurrency toolkit — and it's interactive, so you can play with the concepts as you read. The reception was genuinely warm: people praised it as a distillation of a hard topic.

Milo: But the recurring gripe in the discussion was channel-closing. Even in a resource this good, the commenters kept coming back to how messy closing channels is in Go — who closes what, when, and how you avoid the classic panics and leaks. It's a known wart in the language, and it surfaced immediately.

Mia: That's a nice example of a good explainer still bumping into a genuinely awkward design. The mini-book can teach it, but it can't make it elegant.

Milo: Next, Floci — and this one got a lot of love. It's MIT-licensed local emulators for the big four clouds: AWS, Azure, GCP, and OCI. Twenty-four millisecond startup, no auth tokens required, and — this is the key part — real engines underneath. Actual Lambda, actual RDS, actual Redis.

Mia: So it's not mocking the API surface, it's running the actual service engines locally. That changes the game for testing — you can spin up something that behaves like the real thing in 24 milliseconds without touching credentials.

Milo: And yes, the discussion absolutely caught this: the name means "pubic hair" in Romanian. The commenters did not let that slide. Which is a small thing, but it's the kind of detail that always comes up when a project gets attention.

Mia: Beyond the name, the interesting discussion point was the "real engines" claim versus traditional mock-based tools — if you're running actual engines, your tests exercise real behavior, not an approximation of it. The tradeoff people would naturally raise is fidelity versus resource cost, but the 24ms startup suggests they've worked hard on that.

Milo: Third in this cluster: safe-not-safe.dev, a browser-based checker for whether a Postgres migration is safe. It uses libpg-query compiled to WebAssembly, so the actual Postgres parser runs in your browser. And it's built by someone who ran the Postgres platform at Cloudflare — so the author has real operational scars.

Mia: The standout comment theme: lock_timeout. People who've run Postgres in production stressed it hard — the idea being that a migration's danger isn't just what it does, but how long it holds locks, and you should always set a lock_timeout so a bad migration can't grind your database to a halt.

Milo: Put the three together and there's a real argument: the hardest parts of infrastructure — concurrency semantics, cloud services, migration safety — are being made learnable and testable locally, in the browser, without cloud accounts. Lowering the cost of experimentation.

Mia: And notice how this connects forward too: tools like Floci exist because developers want to control their own environments instead of renting everything from a platform. Which is — conveniently — exactly the theme of our next two stories.

Milo: First, Apple in court. Banks won class certification in an antitrust suit against Apple Pay. The claim: Apple blocks rival NFC wallet apps from the iPhone's NFC hardware, which locks banks into Apple Pay, and Apple charges fees for the privilege — roughly a billion dollars a year. The structure is 0.15 percent on credit transactions and half a cent on debit.

Mia: So the banks are suing over those fees, arguing they only exist because Apple blocked competition. And there's a timeline note that the commenters picked up on: iOS 18.1 opened NFC access in some regions. Which complicates the picture — if the block has started to loosen, does that change the damages story, or the merits?

Milo: That's the unresolved piece: the class is certified, so this moves forward, but the interplay between the historical block and the recent opening is going to be fought over. The billion-dollar-a-year figure is the stakes.

Mia: Now Automattic, and honestly this story reads like a thriller. The WordPress company's board attempted to oust CEO Matt Mullenweg — and the attempt lasted thirty-three hours before failing.

Milo: Why did it fail? Because Mullenweg holds 84 percent of the voting shares. The board could deliberate for a day and a half, but the votes were never there. And afterward, he replaced the board — the new members include Hugh Howey, the author, and the IRL co-founders.

Mia: And the parallel between the two stories is what the discussion kept returning to: founder leverage over closed ecosystems. Apple controls the iPhone's NFC hardware and monetizes the block. Mullenweg controls 84 percent of the votes and can dissolve a board that crosses him. In both cases, governance — or platform control — concentrates power in one place, and when there's a fight, that concentration decides the outcome.

Milo: The 33-hour detail is doing a lot of work narratively. Someone presumably thought they had the votes or the will, and the math said otherwise. Whether that was a genuine governance check that failed, or a power struggle that was always doomed — the sources don't say, and it's genuinely unknown what happens to Automattic's board dynamics next.

Mia: Okay — transition time, and it's a natural one: not every ecosystem fight is a court case. Some are just old products with great stories. And the best one today is the origin of Apple Cards.

Milo: This goes back to 2011. The Apple Cards app — the letterpress greeting-card service — was conceived by Steve Jobs himself, internally under the project name "Speed Racer." Which, knowing Apple's naming habits, is delightful.

Mia: And here's the detail that made the whole discussion light up: invisible UV barcodes. The cards had barcodes printed in ink you can only see under ultraviolet light, working with the USPS. So they could be tracked through the mail invisibly.

Milo: But the story isn't all whimsy. One partner on the project called it the pinnacle of mismanagement. So you've got this Jobs-conceived product, this genuinely clever invisible-barcode trick, and simultaneously a partner who looks back on the whole thing as the worst-run project they'd seen.

Mia: That tension is what makes it a good story rather than a nostalgia piece — the most iconic product stories often have operational chaos underneath. It's unclear from the account where the mismanagement actually bit — timeline, quality, economics — that's left open.

Milo: Then Microsoft — and this one is more of a quiet retreat than a drama. They've dropped the "Copilot+ PC" brand, quietly, while keeping the features that came with it.

Mia: And the commenters had a field day with two things. First, the NPUs — the neural processing units that justified the whole Copilot+ category, the ones rated around 35 to 50 TOPS — largely sit unused. People bought hardware with dedicated AI silicon, and the silicon mostly idles.

Milo: Second, the brand itself: commenters observed that "Copilot" now evokes negative feelings. That's a striking claim — a name that was supposed to signal the future of computing is, per the discussion, becoming a liability. So Microsoft keeps the capabilities, drops the label, and hopes the features can succeed where the marketing didn't.

Mia: The unresolved question there is whether the NPU investment ever pays off — the hardware shipped, the features remain, but the on-device AI use cases that would justify 50 TOPS haven't materialized in the discussion.

Milo: And third in this trio, a story about exit rather than rebrand: the XMPP app Conversations has gone free and is leaving Google Play after twelve years.

Mia: The developer laid out the reasons: the 15 percent store cut — which amounted to around a thousand euros a year — the burden of poor reviews, and delays in shipping security updates because of the Play Store process. Income now comes through grants instead.

Milo: This is the purest "control your own product" story of the three: twelve years on a platform, and the calculus flipped — the fees and friction outweighed the distribution. The thousand-euro figure is small in absolute terms, but for an independent app, that's real money, and the security-update delay point is the one that would worry any user — a messaging app that can't patch promptly is a genuine problem.

Mia: The open question is whether grant funding is sustainable long-term, and whether leaving the store costs more users than the savings justify. But as a statement of values — an XMPP client choosing independence over the default marketplace — it landed well in the discussion.

Milo: Alright, time for our last topic, and it's the heaviest one. The Economist has a piece calling plunging test scores a slow-moving catastrophe. Not a sudden shock — a slow, quiet decline that keeps getting worse.

Mia: And the Hacker News discussion, tellingly, digressed. It drifted into critical slowing down — the systems-theory idea where a system approaching a tipping point recovers from disturbances more and slowly — and then into a whole tangent about jargon itself.

Milo: That digression is almost a meta-commentary on the topic: a genuinely important, slow-burning crisis, and the conversation ends up in the weeds of terminology. Though you could defend it, too — critical slowing down is a real and relevant frame for decline that happens gradually and then possibly tips.

Mia: Why does this belong in the same episode as app-store fees and agent security? Because those problems announce themselves. A court case, a board coup, a bot pulling data — those are events. The test-score decline is the opposite: no event, no headline, just a trend line bending downward year after year. That's what makes it a catastrophe in the Economist's framing — it's too slow to generate urgency.

Milo: The honest unknown here is stark: whether any intervention can reverse the decline. The discussion didn't surface a confident answer. And you can connect it back to the AI threads from earlier in the show — if LLMs reshape how people learn and work, the education trajectory becomes even more consequential.

Mia: But we don't want to leave you on that note, so here's the closer: a quick fiction recommendation. Caroline M. Yoachim's story "Welcome to the Medical Clinic at the Interplanetary Relay Station," published in Lightspeed back in 2016.

Milo: And the best way the discussion described it: it's an ER visit with sci-fi search-and-replace. That's the concept — a mundane medical drama transposed onto an interplanetary relay station, and the fun is in the systematic swapping of the sci-fi elements.

Mia: It's short, it's clever, and after an episode about founder control, agent accountability, and slow catastrophes, a well-executed piece of formally playful science fiction is exactly the right landing pad.

Milo: That's the show, everyone. Mia, good episode.

Mia: Thanks, Milo — and thanks to all of you for listening. We'll see you next time.

Milo: Take care.