Rose Misseur is an API practitioner who works at the intersection of product and engineering, bringing governance into every phase of the API lifecycle across organizations from startups to large banks. In this conversation we start with how AI is changing API governance — not at its core, but in how a pervasive layer of tooling has turned heavy centralized processes into a kind of governance copilot that sits beside every team. From there we trace why centralized models break down at the speed organizations operate today, why the federated model needs guidance from the top and autonomy below, and how spec-driven development and PRDs are pulling product and design into the work far earlier. Rose makes the case that governance is really a people and mindset problem, that the gap between product and engineering should be bridged rather than closed, and that the next hard problem — in a world of shadow APIs and a SaaS apocalypse — is discoverability, because you cannot govern what you cannot see.

Patrick Kelly is the cofounder and CEO of Sideko, a Brooklyn-based API tooling company he started with Elias Posen to turn API specs into developer-friendly SDKs, documentation, and mock servers. In this conversation we trace how that SDK business pivoted toward context engineering as the consumer of APIs shifted from humans to agents, and how the "code mode" technique — handing an agent a generated SDK rather than a wall of tools — turned out to be a perfect reapplication of Sideko's codegen. Patrick walks through the tactical, MCP-level problems he is solving with Port of Context: collapsing many upstream tools into a few, the genuinely hard problem of evaluating whether an agent called the right API in the right order, and the state-control proxy they built to measure what actually happened upstream. We talk about being the catalog and runtime guidance for which technique and which model works best, cleaning up messy specs for MCP generation, and rallying behind open tooling like libopenapi and vacuum.

Manu PK is a solution architect at Schneider Electric, the global energy and industrial technology company, where he helped stand up a Model Context Protocol (MCP) registry for thousands of GitHub Copilot developers. In this conversation we dig into what it actually takes to bring MCP into a company that builds mission-critical industrial systems — why a secure, governed registry mattered more than turning everything on, how distribution and allow-listing work in practice, and which MCP servers map cleanly onto the developer lifecycle. From there we widen out into the API administration problem hiding behind agentic traffic, the MCP-versus-CLI-versus-skills debate, and why Manu chose to share an enterprise playbook publicly when almost everything online assumed personal, single-developer use. We close on the human side of the AI shift, the gradual decay of hard-won skills, and why the people closest to firmware see this moment very differently than the web crowd.

Jennifer Riggins is a freelance technology journalist and event host who writes about the developer experience and the people who live inside it. In this conversation we start with what is actually happening to developers right now — the individual joy of working with AI set against eroding guardrails, precarity, and the sense that we have stopped caring for our technologists. We trace how platform engineering has emerged as the proven conduit for doing AI safely, why agentic swarms are mostly fantasy for enterprises still anchored to the mainframe, and how the real value was always the data and the integration, not the model. Jennifer makes the case for solidarity among technologists, for protecting junior developers as the only path to senior ones, and for treating AI as one tool among many rather than the single way anyone consumes information. We close on the kind of small, facilitated, in-person gatherings she believes can rejuvenate the old meetup energy.

Fran Mendez is the creator of AsyncAPI, the specification for event-driven APIs that now sits alongside OpenAPI and JSON Schema at the core of how we describe our APIs. In this conversation we go back to why he hacked OpenAPI into existence for events, what it actually feels like to own a successful open specification for a decade, and the responsibility, expectations, and thin economics that come with it. Fran is candid about the success of AsyncAPI being "overwhelming" — he stepped back from the organization this year — and about the trap of trying to save a space that never asked to be saved. From there we turn to Commune, the headless Substack alternative he is building now, why he is deliberately building on top of existing email vendor APIs rather than reinventing the wheel, and why the inbox remains one of the last digital spaces where people still hold real control.

Emmanuel Paraskakis has spent more than fifteen years shaping the API products and tools the rest of us build on — API Blueprint at Apiary, Oracle's first cloud-native API Gateway, and Swagger at SmartBear — and now runs Level 250, advising enterprises and AI-forward startups. In this conversation we start where his career started, with the idea that an API is just a product, and trace how the design-first thinking that felt ahead of its time in 2014 has finally become workable now that LLMs and context engineering have removed the friction. Emmanuel walks through his own spec-driven workflow — requirements, domain, and standards documents feeding user stories and then a validated OpenAPI spec — and makes the case that the intermediate format matters far less than having one agreed-upon source of truth. We close on the human side of the work: training the next generation of API product managers, finding signal in the AI noise, why authentic content rises above the slop, and the enduring value of showing up in person.

David Biesack is the Chief API Officer at Apiture, where he designs the API-driven digital banking platform that hundreds of community banks and credit unions run on. In this conversation we go deep into the craft of API design with one of the few people who not only talks about this work at the conferences but goes home and actually builds it. We trace how OpenAPI 3.1 adopting JSON Schema 2020-12 unlocked a data-driven pipeline at Apiture — schema bundling, reference resolution, per-schema versioning, generated release logs, and home-built specification extensions that all validate themselves with JSON Schema. David makes the case for treating your API definition as structured data you can process rather than prose, for keeping the average developer away from reference mayhem, and for staying plugged into the open, generous JSON Schema community. We close on his worry that vibe coding will produce schemas that work for the first twenty percent of cases and break on the rest, and his conviction that the discipline is learnable if practitioners keep sharing.

Daniel Kovac is a product engineer at Speakeasy, where the team turns OpenAPI into deterministic, production-grade SDKs and is now leaning hard into agent skills as the way developers interface with their CLI. In this conversation we start with where SDK developer experience is headed as coding agents like Claude and Codex become the execution layer, and why deterministic generation still matters when an LLM can quietly break a client-to-contract match. From there we get into the relationship between OpenAPI and skills, the role of overlays as a first-class, deterministic enhancement layer, and how Speakeasy formed the structure of its skills — sourcing them from real customer issues, flattening tree-shaped docs, and treating a skill's description as a problem statement rather than a solution. Daniel walks through their eval framework, an agent-feedback loop where agents file complaints about other agents' skills, and the move toward speakeasy agent context as the next abstraction beyond flat skills. We close on design-first development, dogfooding, public versus private skills, and what skills mean for discovery.

Clemens Vasters is a Principal Architect at Microsoft who has spent twenty years building the industrial-grade messaging and eventing backbone of Azure — Service Bus, Event Hubs, Event Grid, Stream Analytics, the relay, and now Microsoft Fabric Eventstreams — while representing Microsoft across messaging standards like AMQP, MQTT, CloudEvents, and xRegistry. In this conversation we dig into JSON Structure, the strictly typed data definition language he created and took to the IETF as an answer to the long, problematic history of JSON Schema. Clemens explains why JSON Schema is a fine validation language but a lousy data definition language, how he cut the dangerous parts — unconstrained any-of/all-of composition and scatter-shot dollar-ref — to leave a clean core with a real type system. We get into metadata as the missing ingredient for better LLMs, the SDK and Avrotize tooling ecosystem, how he tamed reference complexity with a two-step import-then-ref model, extension mechanisms for governance and policy, and why he believes a good spec eventually earns its adoption.

Anna Daugherty leads product marketing at Arnica, where she has carried a career-long focus on developer workflows from the documentation and spec experience at Stoplight, through commercializing Spinnaker at Armory, into application security. In this conversation we trace how AppSec stays a developer-tooling problem at heart, why governance is the question that never goes away no matter the tool, and where in the lifecycle a developer is actually most likely to fix a vulnerability — not the IDE, not the pipeline gate, but the pull request. We get into Arnica's pipelineless, developer-native ethos, the move to inject security rules into rules.md files so the LLM itself follows them at the point of AI code creation, and why the source code layer offers the widest coverage. We close on staying grounded amid the AI hype, real customer validation, and a shared love of preserving the physical and the human.