How I AINever write an update again: Notion's AI-powered engineering meetings | Ryan Nystrom
CHAPTERS
Ryan Nystrom’s AI working style reset: constant tool changes, more joy, more output
Ryan describes how AI disrupted a decade-plus of stable habits, pushing him to switch IDEs, terminals, and workflows repeatedly. Despite the pace, he finds the change energizing and credits AI with making work both faster and more enjoyable.
Project Afterburner: the mission to cut Notion’s CI time by 75%
Ryan introduces Afterburner, a DevX initiative aimed at aggressively reducing CI times to a quarter of current duration. He frames it as an engineering-leverage project: faster feedback loops improve both quality and shipping velocity—especially in an agent-driven world.
Engineering meetings reimagined: daily standups without the dead-eyed status round-robin
Ryan explains why traditional standups often fail: they devolve into rote updates with low engagement. His team keeps meetings high-frequency but makes them high-quality by focusing on decisions, problems, and learning rather than individual reporting.
The automated pre-read: surfacing Slack, PRs, tasks, and yesterday’s transcript into one agenda
A Notion AI custom agent compiles a meeting pre-read by scanning the last 24 hours across Slack, merged PRs, closed tasks, and prior meeting notes. This creates a shared, detailed agenda so the team can start immediately with what matters.
“Equal visibility” for every engineer: democratizing updates and catching missed wins
Ryan and Claire discuss how automation creates a level playing field: quieter engineers’ work is captured as reliably as more vocal teammates’. The artifact also helps the team notice improvements (like CI/test speedups) that might otherwise slip by.
Burnout protection via just-in-time prep: reclaiming manager and maker time
Reducing meeting-prep overhead removes daily context switching and the “paperwork” burden that drains leaders. Ryan argues this is a concrete burnout prevention mechanism—freeing managers to stay hands-on, creative, and close to the work.
How the Notion custom agent is built: triggers, instructions, subagents, permissions, and MCP metrics
Ryan walks through the “Hot Potato” custom agent configuration: scheduled triggers, a detailed instruction page, and a structured output template. He also explains careful permissioning (read-only for most data, edit only for meeting notes) and using MCP to pull telemetry (Honeycomb).
From prompts in terminals to prompts in Notion: the workflow that leads to “Boxy”
Ryan describes the friction of writing prompts in CLIs and copy/pasting between tools. Notion becomes the place to draft structured prompts and tasks, leading to an internal system that can invoke coding agents directly from Notion work items.
Inside Boxy: @mention Codex to spin up VMs, implement UI changes, and open PRs
A simple feature request from a friend becomes a live demo: Ryan writes a short task with a screenshot and edge cases, then @mentions Codex in a Notion comment. Boxy runs the work on background VMs, returns a PR and preview URL, and even attaches UI verification screenshots.
Old-world vs new-world code review: asking “I don’t get it” without social cost
Ryan and Claire highlight how AI changes the emotional dynamic of code review. Ryan can candidly say “I don’t understand this—explain like I’m five,” pushing for clarity and correctness without interpersonal friction.
Spec-first development in practice: speaking a spec, checking it into the repo, then ‘Build it’
Ryan explains Notion’s agent harness rewrite and the shift to starting with specs instead of code. He uses Whisper to “yap” requirements, has Codex convert it into a structured markdown spec, then points Codex at the spec to implement the feature nearly end-to-end.
The spec as changelog: version control for how the system actually works
Treating the spec as the source of truth enables clearer evolution than code diffs alone. Updating behavior becomes “update the spec, then regenerate/adjust the implementation,” making intent legible to humans and machines across time.
Engineers as architects and verification designers: roles evolving around evaluation loops
Ryan argues engineers’ value shifts toward systems thinking and creating strong verification loops that agents can execute. The key bottleneck becomes correctness and evaluation—not hand-wiring every integration detail.
Lightning round: why Codex, why CI speed matters more with agents, and prompting when things go wrong
Ryan and Claire compare Codex to other agents, emphasizing long-running task stability and one-shot workflows. They tie CI speed directly to the throughput of both humans and agent swarms, then share prompting strategies: challenge sycophancy and demand evidence-based defenses.
Where to find Ryan and closing notes
Ryan shares where he’s most reachable and offers to help troubleshoot Notion issues. The episode wraps with standard podcast closing and calls to engage.
Get more out of YouTube videos.
High quality summaries for YouTube videos. Accurate transcripts to search & find moments. Powered by ChatGPT & Claude AI.
Add to Chrome