Where does our data go? Learn residency, isolation, workflow dependencies, operational ownership, on-prem support, release parity and prioritization. Nine spoken chapters. Fictional examples; not legal advice. Sources: AWS SaaS Lens, Temporal docs, EDPB Guidelines 05/2021, GDPR and Kubernetes version policy.

An AI agent finds a lock that slows an AI service. Is that recursive self-improvement, or good engineering? This story-first lesson separates faster serving, automated training experiments, self-modifying agent software, and autonomous successor-building.

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

What happens to security when the decisions are made inside the building? A story-first look at Runta, the startup that raised a $20M seed led by a16z to build an "execution layer" for AI agents: how it limits what an agent can reach, spend and leave a record of, the honest counter-case, and four takeaways for anyone building with agents.

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/

Description: A PM says "we can do that later" to protect an engineer's time. Three days before launch, nobody knows what the team actually promised. This lesson asks how to keep a launch urgent without turning people into a deadline's fuel: make the date's purpose explicit, negotiate the smallest honest release, welcome bad news early, own the trade-offs and clear the team's path. A story-first, applied lesson for PMs and engineering leaders. The opening team is an invented composite, not a report of a real company.

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/

Why are invites to a free product selling on eBay for $300? This episode digs into the first long interview with Noah Shinn, founder of Instinct - a personal AI assistant with no app that you text, call, or email like a person. Invite-only, zero marketing spend, growing ~10% a day, with over $1B a year in transactions already flowing through it.

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

A distilled audio lesson from the Latent Space conversation with OpenRouter co-founder and CEO Alex Atallah and a16z general partner Anjney Midha. Why tokens are becoming a new unit of internet value, why fraud against the token flow is compounding, what the Stripe acquisition of OpenRouter is really about, and the lessons on focus, distribution, and being called just a wrapper. Source: Latent Space podcast, youtube.com/watch?v=dCX4PE2HxMs. Independent synthesis and narration, not the original recording.

When should you use an agent instead of a simpler workflow? This applied 50-minute lesson covers retrieval and context, tools and permissions, memory, orchestration, data, evaluation, safety, coding agents, and proactive agents. The thread is how to make a system that can finish real work without hiding failures or taking the wrong action.

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

An engineer's claim of 2,000+ production pull requests in a month, and the real story underneath it: how verification loops, feature maps, and a five-layer trust ladder turn AI coding agents from babysat interns into a Michelin kitchen that runs itself. Sources: x.com/poteto/status/2102050467505430555 | github.com/cursor/plugins/tree/main/pstack | github.com/michael-denyer/pstack-claude | maven.com/p/e23d9c/how-cursor-turned-ai-agents-into-better-engineers | flaviocopes.com/pstack | thenewstack.io/agentic-verification-distributed-systems

Part of the Dev Tools for PMs series.

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.

Part of the Dev Tools for PMs series.

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.

Part of the Dev Tools for PMs series.

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.

Part of the Dev Tools for PMs series.

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.

Part of the Dev Tools for PMs series.

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.

Part of the Dev Tools for PMs series.

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.

Part of the Dev Tools for PMs series.

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

Part of the Dev Tools for PMs series.

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.

Code written against Stripe's API in 2011 still worked years later, because the company treated its API as a promise. This series finale covers how product management changes when your product is a contract that other people's software, and now their agents, depend on. We cover Hyrum's Law, how Stripe and Shopify handle change without surprising anyone, and why an API review process can turn into a bottleneck. We look at the small trust features developers love, how to measure and prioritize on a platform, and what changes when the developer is an agent. Then we zoom out on the whole series.

Doctors call the hours they spend finishing notes at home "pajama time." When one of the largest US health systems rolled out an AI scribe across 28 hospitals, it didn't pick the smartest general model. It picked the product that understood the job: billable formats, 55 specialties, and a quick way for doctors to check every line. This episode explains why AI products that win in a field often look less like a clever model and more like a deep understanding of one job. We look at examples from healthcare and law, the difference between workflows and agents, and where the best targets are. Then we make the honest case that general models are catching up.

In late 2025, Workday, an HR and finance software company, agreed to buy a developer platform with thousands of app connectors. Around the same time, the big AI labs launched their own connector directories and independent startups raised big rounds. Everyone wants the same spot: the layer between an AI agent and the software it acts on. This episode maps the four kinds of players fighting for it: model companies, systems of record, breadth players and independent specialists. It covers what's becoming table stakes and where value is moving. It also makes an honest case for why bundling usually wins, and explains where a smaller company can still win.

Every day, one AI code editor gets more than 400 million tiny votes: did you press Tab to accept a suggestion or not? It retrains on those votes many times a day. Meanwhile a leading legal AI company quietly moved away from betting on its own custom model. This episode asks when "our product gets better the more people use it" is a real moat and when it's just a story. We cover why most data advantages are scale effects that fade, and how new foundation models can erase a custom-model lead. We also cover the kinds of data that really do compound: product-specific feedback loops, true cross-customer networks like fraud detection, your own evaluations, and customer context.