We examine Z.ai's infrastructure report, DeepMind's AlphaEvolve, Karpathy's autoresearch, Sakana's Darwin Godel Machine, Weco's AIDE-squared, and current lab measurements. The counter-case: weak feedback, proxy gaming, diminishing returns, and bottlenecks outside the loop.

Independent synthesis as of October 4, 2026. Lab and practitioner results are attributed claims, not independently reproduced measurements. Direct X posts and three full X Articles were read; this is a targeted sample, not an exhaustive scrape. Narration is AI-generated.

Chapters:

The model and the slow machine

Faster serving is not a smarter model

The overnight experiment worker

When the researcher edits itself

What the frontier labs actually say

The counter-case and the builder's test

Sources:

Z.ai: https://z.ai/blog/glm-built-its-inference-infrastructure

Public FLA accuracy fix: https://github.com/fla-org/flash-linear-attention/pull/1180

DeepMind AlphaEvolve: https://deepmind.google/blog/alphaevolve-a-gemini-powered-coding-agent-for-designing-advanced-algorithms/

Karpathy's reported gains: https://x.com/karpathy/status/2031135152349524125

Autoresearch code: https://github.com/karpathy/autoresearch

Sakana DGM: https://sakana.ai/dgm/

Weco AIDE-squared: https://arxiv.org/abs/2609.26457v1

OpenAI: https://openai.com/index/research-acceleration-view-inside-openai/

Anthropic: https://www.anthropic.com/institute/measuring-pace-of-ai-development

METR: https://metr.org/notes/2026-07-22-economics-of-recursive-self-improvement/

Nathan Lambert: https://www.interconnects.ai/p/where-i-stand-on-rsi

X Articles:

https://x.com/hooeem/status/2030720614752039185

https://x.com/ashpreetbedi/status/2084301728363462919

https://x.com/IntuitMachine/status/2078419526354378975

Sources:

Runta launch post: https://runta.com/blog/runta-the-execution-layer-for-agents/

a16z, Investing in Runta: https://a16z.com/announcement/investing-in-runta/

The Next Web: https://thenextweb.com/news/runta-a16z-seed-ai-agent-infrastructure

Runta About: https://runta.com/about/

Sources:

Malte Ubl, How to ship: https://www.industrialempathy.com/posts/how-to-ship/

Camille Fournier, Notes on Startup Engineering Management for Young Bloods: https://www.camilletalk.com/whilefalse/2015/10/notes-on-startup-engineering-management.html

Charity Majors: https://charity.wtf/p/shipping-software-should-not-be-scary

Marty Cagan: https://www.svpg.com/the-need-for-speed/

Amy Edmondson: https://www.hbs.edu/faculty/Pages/item.aspx?num=12357

Deci, Connell and Ryan: https://selfdeterminationtheory.org/SDT/documents/1989_DeciConnellRyan.pdf

DORA 2024: https://dora.dev/research/2024/dora-report/

We cover the wildest real use cases, the trust numbers (40% of users share a credit card within 3 weeks; 80% retention after the first sensitive connection), agents coordinating with other people's agents, why he refuses an ad model, the take-rate bet, which businesses win or lose in an agent-rich world, and the compute math that keeps a founder up at night.

An independent synthesis and narration of the Invest Like the Best conversation "Noah Shinn - Building Instinct: The Personal Agent" (EP.493), hosted by Patrick O'Shaughnessy - this is not the original recording.

Source episode: https://colossus.com/episode/instinct-the-personal-agent/

Original post: https://x.com/patrick_oshag/status/2104542892073095398

An independent synthesis based on the public Stanford CS329Z: Engineering AI Agents syllabus, the first lecture slides, and selected readings as of September 27, 2026. This is not a class recording or official Stanford course material. Later lectures had not yet taken place and their slides were not public when this episode was made.

Course: https://cs329z.stanford.edu/

First lecture slides: https://cs329z.stanford.edu/static/slides/lecture01.pdf

A user asks an AI agent "How do I find my W-3 on Paychex?" - and the model confidently explains how to find a W-2 instead. That wrong-form session is the opening of Perplexity's research post "Learning from Real-World Experience," and this episode unpacks it. How do you train an AI product on real usage without imitating its mistakes? Perplexity's answer: judge turns, not sessions - imitate the good steps, correct the avoidable ones with hint-guided self-distillation, and trace complaints back to their true root cause. We walk the full pipeline (privacy filters, paired LLM judges, hindsight-bias checks, the training pass) and the refreshingly honest evaluations: tool errors fell 21% relative in live A/B tests, while user dissatisfaction didn't measurably move. What it means for any PM building a learning loop.

In 2009, Twilio's Jeff Lawson stood in front of a thousand people at a San Francisco meetup and, instead of explaining his product, live-coded a conference line and asked everyone to phone in. The room went wild, and that demo became the template for how developer products grow. This episode unpacks the playbook Twilio invented: self-serve onboarding, usage-based pricing, and expansion by default (its IPO filing showed ~155% net dollar expansion). Then the modern remix: how Vercel, Supabase, and Resend use open source as the wedge and launch rituals as the growth channel. Plus the honest counter-case: survivorship bias, the enterprise wall, and why developer love alone doesn't pay salaries.

Air Canada's chatbot invented a bereavement refund policy that didn't exist, and a tribunal made the airline honor it. That's what shipping an AI product without evals looks like. This episode covers what evals actually are and how practitioners build them, with Madhu Guru's ten-part series as the spine: start from real traces, write the rubric before you measure, name failures precisely, run a ladder of evals, and never collapse everything into one average. Plus Hamel Husain on why failed AI products share one root cause. Then the counter-case: evals are a craft with open problems - judge reliability, trajectory traps, and real cost.

When McKinsey claimed in 2023 that you can measure software developer productivity, Kent Beck and Gergely Orosz publicly pushed back - and the fight exposed the hardest question in engineering management. This episode covers the measurement stack that actually survived scrutiny (DORA, SPACE, DevEx, and the DX Core 4), and then flips to the metric every dev-tool PM owns: time to first hello world, and the adoption funnel after it. Then the counter-case: Goodhart's law eats every metric, frameworks built for systems keep getting aimed at people, and five watched developers beat a dashboard.

Stripe's docs embed your own API test key in their code samples, so the first thing you run just works - and they've treated documentation as a product since before their Series A. This episode covers the product around the API: docs as the developer onboarding flow, the Divio framework that splits documentation into four distinct kinds (tutorials, how-to guides, reference, explanation), docs-as-code, and why the SDK, not the API, is the interface developers actually love. Then the counter-case: docs can't rescue a confusing API, a stale SDK is worse than none, and docs page views are a vanity metric.

On March 22, 2016, a developer unpublished eleven lines of code called left-pad and thousands of builds around the world failed within minutes. This episode is about how grown-up platforms avoid that: deprecation policies that promise exact timelines, changelogs written for humans, and migration windows with real migration guides. We cover Kubernetes' and Google Cloud's published policies, the new RFC 9745 Deprecation header, and the Google Reader shutdown as the case study in what killing a product costs. Then the counter-case: ceremony must scale with blast radius, and deprecation notices get ignored anyway.

When Microsoft shipped Windows 95, it added a special memory mode just for SimCity, which had a bug that only worked on the old system. That is the extreme end of backwards compatibility, and this episode asks what you owe the software that depends on you. We cover Hyrum's Law and the implicit interface, what actually counts as a breaking change, the versioning dialects (SemVer, Stripe's rolling date versions, Shopify's quarterly calendar), and what infinite compatibility costs. Then the counter-case: Apple's camp let old apps break and moved faster, and early products should break freely. The one unforgivable version is breaking people silen

In 2008, Twilio launched with a demo that rebuilt a phone service in fifteen lines of code, turning a months-long telecom project into an afternoon. This episode asks what separates an API developers love from one they endure. We cover Joshua Bloch's classic maxims for good API design, resource-oriented design from Google's public API guide, how Stripe designs by watching developers integrate live, and why failure handling like idempotency belongs in product requirements. Then the counter-case: design-first is not a religion, internal APIs play by different rules, and a beautiful API with bad docs still fails.

Chapters:

00:00 Cold open: the agent that faked its tests

02:47 Chapter 1 - From internet text to practice worlds

15:42 Chapter 2 - What makes a good environment (and why most are bad)

31:31 Chapter 3 - When the student cheats

43:30 Chapter 4 - The environment economy, and the case against

54:36 Wrap-up: the whole hour in four sentences