The Developers' Bakery

The Developers' Bakery

By Nicola Corti, Marco Gomiero, Paolo RotoloTechnologyEducationHow To
Download on the App Store

The Developers' Bakery episodes

  • Do we still need Android Studio?

    Do Android developers still need Android Studio, or just any IDE? With AI agents writing and navigating more of our code, the IDE’s role is changing. However some tools such as debuggers & profilers are hard to replace.

    In this Fresh from the Oven episode, Nicola, Marco, and Paolo talk through that shift. Marco shares a preview of his upcoming droidcon London talk, “Do we still need Android Studio?”, and the three compare how they use IDEs, terminals, desktop agent apps, and command-line tools in their day-to-day work.

    We dig into the features that still bring developers back to Android Studio, whether those tools should be available on their own, and how Android CLI is making more of the development workflow accessible to agents.

    Enjoy the show 👨‍🍳

    Show Notes
    • 00.00 Intro
    • 00.52 Episode Start
    • 01.35 Do we still need Android Studio?
    • 05.00 How AI is changing the role of IDEs
    • 12.31 Where to run coding agents: terminal or desktop?
    • 21.26 The Android Studio tools worth keeping
    • 29.55 Should developer tools run outside the IDE?
    • 32.18 Android CLI: built for agent workflows
    • 38.41 Recipe of the week
    • 45.30 Droidcon London and closing
    • Resources
      • Marco Gomiero’s droidcon London speaker page - his talk, “Do we still need Android Studio?”
      • droidcon London 2026 - December 10–11 in London
      • Android CLI
      • iTerm2 Session Status and Toolbelt - see which terminal sessions are working, waiting, or idle
      • Herdr - a terminal workspace for running coding agents
      • Moshi - a mobile terminal for coding agents and remote development
      • Clean Code Revisited in the Age of AI — Danny Preussler - droidcon USA 2026 talk
      • Hosts:

        • @cortinico on GitHub
        • @cortinico on X
        • @prof18 on GitHub
        • @marcoGomier on X
        • @paolorotolo on GitHub
        • @paolorotolo on X
        • Show links
          • Podcast Website
          • The Developers’ Bakery on Spotify
          • The Developers’ Bakery on Apple Podcasts
          • The Developers’ Bakery on Google Podcasts
          • @thebakerydev on X
          • 47 min
          • Building with AI and curiosity with Ivan Morgillo

            What changes when AI can take care of the tedious parts of building software, and help you try ideas that once felt out of reach?

            Today we’re joined by Ivan Morgillo, an Android engineer, indie developer, and longtime tinkerer. Ivan explains why he treats AI as an assistant for the annoying work, from wiring up Home Assistant to managing a fleet of coding sessions from his phone.

            We get into his agent workflow: using Claude Code as an entry point, asking several models to review plans and code, and building ship-feature to coordinate the process. Ivan also describes how he added persistent memory with MemPalace, originally to keep a long-running Dungeons & Dragons campaign going across conversations.

            The conversation ranges from jailbreaking a Kindle and using a webcam as a feedback loop, to custom hardware controls, fixing memory leaks in the Elgato Stream Deck app, and asking AI to “clean” a Chromecast. We finish with indie app ideas, the story behind Ivan’s Smart Pantry app, and his advice to live an interesting life so you encounter interesting problems to solve.

            Enjoy the show 👨‍🍳

            Show Notes
            • 00.00 Intro
            • 00.33 Episode Start
            • 01.26 Meet Ivan Morgillo
            • 04.31 His AI assistant handles the annoying stuff
            • 08.00 Coding from anywhere with an always-on agent setup
            • 11.21 How Ivan gets AI to plan, build, and review
            • 15.27 Giving AI a memory for a D&D campaign
            • 21.19 How AI helped jailbreak an old Kindle
            • 27.05 Hardware hacking is back (thanks to AI)
            • 38.50 Four models review every code change
            • 43.46 What becomes possible when code gets cheap?
            • 49.13 A pantry problem turns into a profitable app
            • 52.17 The best ideas start with an interesting life
            • Resources
              • Ivan Morgillo’s website - projects, writing, and links
              • @hamen on GitHub
              • @hamen on X
              • Ivan Morgillo on LinkedIn
              • ship-feature - Ivan’s open-source workflow for planning, implementation, and agent reviews
              • MemPalace - local-first persistent memory for AI agents
              • Home Assistant
              • Kindle Gratis - find free Kindle books
              • Smart Pantry - Ivan’s food and expiry-date tracking app
              • Code with the Italians - Ivan’s podcast with Sebastiano
              • MAKE by Pieter Levels - the book about building startups that Ivan mentions
              • Marco:

                • @prof18 on GitHub
                • @marcoGomier on X
                • Nicola:

                  • @cortinico on GitHub
                  • @cortinico on X
                  • Show links
                    • Podcast Website
                    • The Developers’ Bakery on Spotify
                    • The Developers’ Bakery on Apple Podcasts
                    • The Developers’ Bakery on Google Podcasts
                    • @thebakerydev on X
                    • 56 min
                    • Android developer verification and the future of sideloading

                      Android is introducing developer verification for apps installed on certified devices, including apps distributed outside Google Play. What does that mean for sideloading, open source projects, and the way Android developers share their work?

                      In this Fresh from the Oven episode, Nicola, Marco, and Paolo discuss the ADV rollout and its goals of making it harder to forge malicious apps. They walk through app registration, identity checks, and the advanced flow users can enable to install unverified apps after a (sadly long) 24-hour wait.

                      Join us in this episode, as we talk through Play Console stories, account suspensions, the 20-developers requirements, and what it means for Android’s reputation as an open platform.

                      Enjoy the show 👨‍🍳

                      Show Notes
                      • 00.00 Intro
                      • 00.33 Episode Start
                      • 01.44 What is Android developer verification?
                      • 03.43 Identity checks and sharing a home address
                      • 04.36 Where and when enforcement starts
                      • 05.39 How app and developer verification works
                      • 06.15 Google’s safety goals and impersonation scams
                      • 07.38 Sideloading, ADB, and the advanced flow
                      • 08.38 The 24-hour wait and open source apps
                      • 10.03 Android’s promise of an open platform
                      • 12.12 The Keep Android Open campaign
                      • 13.04 Account suspensions and developer identity
                      • 16.04 Play Console warnings and automation
                      • 23.13 Limited distribution for students and hobbyists
                      • 26.10 Closed testing and the 20 testers requirement
                      • 27.35 AI makes building apps faster; distribution remains hard
                      • 30.00 Indie apps and the value of open distribution
                      • 34.52 Finding testers for closed testing
                      • 36.36 Internal apps and enterprise distribution
                      • 41.24 What happens next?
                      • 42.05 Closing
                      • Resources
                        • Android developer verification.
                        • Building a safer Android ecosystem together - rollout regions, participating stores, and the advanced sideloading flow
                        • Register for limited distribution - Share apps with up to 20 authorized devices
                        • Android developer verification FAQ
                        • Register package names with the Android Developer Console API - API for registering app package names
                        • Keep Android Open - Community campaign and open letter about the policy
                        • Hosts:

                          • @cortinico on GitHub
                          • @cortinico on X
                          • @prof18 on GitHub
                          • @marcoGomier on X
                          • @paolorotolo on GitHub
                          • @paolorotolo on X
                          • Show links
                            • Podcast Website
                            • The Developers’ Bakery on Spotify
                            • The Developers’ Bakery on Apple Podcasts
                            • The Developers’ Bakery on Google Podcasts
                            • @thebakerydev on X
                            • 44 min
                            • Building developer conferences with Greg Fawson

                              What does it take to build a developer conference that still feels like it belongs to its community?

                              Today we record in person in Berlin, with Greg Fawson, CEO of droidcon Global. Greg is going to share what happens behind the scenes of bit tech conferences: how droidcon grew from a 200-person gathering in 2009 into a global conference series, and why balancing attendees, speakers, sponsors, venues, and logistics is a constant juggling act.

                              We revisit the post-COVID decline of local meetups, a New York venue whose jet-fuel-powered air conditioning turned into a wind tunnel 🍃, and the ways Android’s evolution changed conference agendas. Greg also describes how AI is affecting talk submissions, session selection, company travel budgets, and the value of meeting other developers in person.

                              Finally, we look ahead to next.app DevCon, which brings Android, Flutter, iOS, React Native, mobile security, XR, mobile games, and agentic coding together while preserving dedicated spaces for each community.

                              Enjoy the show 👨‍🍳

                              Show Notes
                              • 00.00 Intro
                              • 01.09 Episode Start
                              • 01.38 The hardest part of building a developer conference
                              • 04.59 How droidcon started
                              • 08.58 droidcon today
                              • 12.02 COVID’s impact on developer communities
                              • 15.07 Conference mistakes and the New York wind tunnel
                              • 21.52 How droidcon and Android changed
                              • 25.46 How AI is changing conference talks
                              • 28.22 Reviewing AI-generated talk submissions
                              • 31.58 AI, ticket sales, and the value of meeting in person
                              • 38.38 Building next.app DevCon
                              • 44.15 Cross-pollination across mobile communities
                              • 50.05 Advice for new conference organizers
                              • 52.16 Where to find Greg online
                              • 53.06 Closing
                              • Resources
                                • droidcon Global
                                • next.app DevCon
                                • Greg Fawson on LinkedIn
                                • Hosts:

                                  • @cortinico on GitHub
                                  • @cortinico on X
                                  • @prof18 on GitHub
                                  • @marcoGomier on X
                                  • @paolorotolo on GitHub
                                  • @paolorotolo on X
                                  • Show links
                                    • Podcast Website
                                    • The Developers’ Bakery on Spotify
                                    • The Developers’ Bakery on Apple Podcasts
                                    • The Developers’ Bakery on Google Podcasts
                                    • @thebakerydev on X
                                    • 54 min
                                    • Difftray and the agentic code review loop

                                      When coding agents can produce changes faster than you can inspect them, what does a useful code review look like?

                                      In this Fresh from the Oven episode, Marco walks us through his agentic development setup. He explains how he reviews plans and architecture before implementation, how he uses fresh contexts and different models to review generated code, and why the signals he looks for are changing as code becomes a commodity.

                                      The core of the conversation is Difftray, Marco’s local-first review desk for Git changes. Marco built it after repeatedly losing track of files that an agent had changed after his first pass.

                                      Difftray remembers which files were reviewed, flags them when their diffs drift, and turns inline review comments into a prompt that can be sent back to the agent.

                                      We also explore Marco’s remote workflow: HTML plans in Obsidian, Codex and Claude Code running on his Mac Studio, Difftray Companion on his phone, Tailscale for private remote access, and plenty of Git worktrees for parallel agents.

                                      Enjoy the show 👨‍🍳

                                      Show Notes
                                      • 00.00 Intro
                                      • 00.59 Episode Start
                                      • 01.43 Do we still review agent-written code?
                                      • 06.01 From prompt to code review
                                      • 09.08 Marco’s models and coding agents
                                      • 11.27 Planning with agents
                                      • 15.36 Why Marco built Difftray
                                      • 20.04 Turning review comments into prompts
                                      • 24.42 Reviewing code from a phone
                                      • 28.36 Marco’s remote agentic setup
                                      • 32.03 Parallel agents and Git worktrees
                                      • 34.41 Bringing agent reviews into Difftray
                                      • 36.43 Do developers still need an IDE?
                                      • 42.06 FOSDEM 2027
                                      • 44.26 Recipe of the Week
                                      • 48.44 Closing
                                      • Resources
                                        • Difftray - Marco’s local-first review desk for Git changes
                                        • Difftray on GitHub
                                        • HTML Shelf on GitHub - Marco’s Obsidian plugin for browsing HTML plans on desktop and mobile
                                        • Obsidian
                                        • Tailscale
                                        • OpenCode
                                        • FOSDEM 2027
                                        • Recipe of the Week:
                                          • Marco: Archify
                                          • Nicola: Zencastr
                                          • Paolo: GitHub stacked pull requests
                                          • Marco:

                                            • @prof18 on GitHub
                                            • @marcoGomier on X
                                            • Paolo:

                                              • @paolorotolo on GitHub
                                              • @paolorotolo on X
                                              • Nicola:

                                                • @cortinico on GitHub
                                                • @cortinico on X
                                                • Show links
                                                  • Podcast Website
                                                  • The Developers’ Bakery on Spotify
                                                  • The Developers’ Bakery on Apple Podcasts
                                                  • The Developers’ Bakery on Google Podcasts
                                                  • @thebakerydev on X
                                                  • 50 min
                                                  • Making coding agents your own with Iury Souza

                                                    How much of your coding agent can you make your own? Today we’re recording in person during the GDE Summit, with Iury Souza, a mobile developer and platform engineer who loves tinkering with his dev tools.

                                                    Iury takes us through his agentic development setup with OpenCode and Pi, from choosing models for planning and implementation to teaching an agent to build its own extensions. We explore what a harness actually does, how skills and AGENTS.md shape the context a model sees, and why sharing your perfect setup can be just as tricky as sharing your dotfiles.

                                                    We also talk about the future of terminal interfaces, the reality of running local models on a laptop, and how to keep up when agents produce more work than you can comfortably review. Iury shares his experiments with annotated plans and his open-source Visual Artifact Renderer, which turns agent output into visual explanations, code reviews, and dashboards.

                                                    Enjoy the show 👨‍🍳

                                                    Show Notes
                                                    • 00.00 Intro
                                                    • 00.46 Episode Start
                                                    • 01.09 Yuri’s Introduction
                                                    • 02.00 What is your AI stack?
                                                    • 04.05 Building your own harness
                                                    • 05.57 The first thing you change in your harness
                                                    • 07.45 Sharing your harness customization
                                                    • 10.29 Using Graphical IDEs with AI?
                                                    • 12.32 Local models
                                                    • 15.46 What’s next for agentic development?
                                                    • 19.00 Yuri’s favorite creators
                                                    • 20.25 Where people can find you online?
                                                    • Resources
                                                      • OpenCode - Iury’s main coding harness
                                                      • Pi - the extensible coding agent behind his experiments
                                                      • Visual Artifact Renderer on GitHub - Iury’s tool for visual explanations, reviews, and dashboards
                                                      • My 26-Q1 Agentic Coding Workflow - more background on Iury’s setup
                                                      • @iurysza on GitHub
                                                      • @iurysza on x
                                                      • Iury’s Website
                                                      • Show links
                                                        • Podcast Website
                                                        • The Developers’ Bakery on Spotify
                                                        • The Developers’ Bakery on Apple Podcasts
                                                        • The Developers’ Bakery on Google Podcasts
                                                        • @thebakerydev on Twitter
                                                        • @cortinico on Twitter
                                                        • 22 min
                                                        • 99 episodes, and everything I got wrong

                                                          One hundred episodes. 🎉

                                                          When this podcast started back in 2020, as one of those pandemic side projects, I would have never thought we would reach this milestone. Yet here we are, five years later.

                                                          To celebrate, we’re turning the format upside down: today I’m the one under the spotlight, and I’m not alone in the bakery. Marco Gomiero, who you might remember from episode #52, and Paolo Rotolo are on stage with me, recorded in person here in Berlin, and they get to ask the questions for once.

                                                          We talk about how this show came to be, the six months I spent building the infrastructure before recording a single word, why the “one open source project per episode” rule slowly turned into a cage, the episodes I regret, what it’s like to travel the world with a microphone that looks like a bomb on an X-ray, and why I came very close to stopping at 99.

                                                          And then we look ahead. From today Marco and Paolo are officially co-hosts of this show, and the bakery gets two kinds of episodes: Deep Dives with a guest, and Fresh from the Oven, where the three of us pick a topic and dig into it. We’re also opening a new segment, the Recipe of the Week, where each of us shares a small tool or trick we picked up recently.

                                                          Thank you to everyone who listened, shared, and came on stage over these 100 episodes. Here’s to the next batch 🍞

                                                          Enjoy the show 👨‍🍳

                                                          Chapters
                                                          • 00.00 Intro
                                                          • 00.58 Episode Start
                                                          • 03.13 Nico is under the spotlight!
                                                          • 05.33 The origin of the bakery
                                                          • 08.02 Going too niche?
                                                          • 11.57 Evolving this podcast
                                                          • 13.09 Regrets and mistakes
                                                          • 16.09 Travelling with a microphone
                                                          • 19.47 Finding guests
                                                          • 21.26 Tales from OSS maintainers
                                                          • 26.38 What all OSS maintainers have in common?
                                                          • 30.49 AI & Open Source
                                                          • 36.55 New co-hosts and new formats!
                                                          • 40.26 Recipe of the week
                                                          • 45.28 Where people can find us?
                                                          • Resources
                                                            • Recipe of the week:
                                                              • Nicola: Vowen, a free and fully local alternative to Wispr Flow
                                                              • Marco: Code review comments are the rules you forgot to write down, a loop to keep AGENTS.md up to date from past PR review comments
                                                              • Paolo: Android CLI, an alternative to token-hungry MCP servers
                                                              • Mentioned Resources:
                                                                • prof18/RSS-Parser on GitHub - 10 years old this June!
                                                                • FeedFlow - Marco’s multiplatform RSS reader
                                                                • AppIntro/AppIntro on GitHub
                                                                • #52 - RSS-Parser with Marco Gomiero
                                                                • Marco:

                                                                  • @prof18 on GitHub
                                                                  • @marcoGomier on x
                                                                  • @marcogom on Mastodon
                                                                  • Marco’s Website
                                                                  • Paolo:

                                                                    • @paolorotolo on GitHub
                                                                    • @paolo.rotolo.dev on Bluesky
                                                                    • @paolorotolo on Mastodon
                                                                    • Paolo’s Website
                                                                    • Show links
                                                                      • Podcast Website
                                                                      • The Developers’ Bakery on Spotify
                                                                      • The Developers’ Bakery on Apple Podcasts
                                                                      • The Developers’ Bakery on Google Podcasts
                                                                      • @thebakerydev on x
                                                                      • @cortinico on x
                                                                      • 48 min
                                                                      • Android MCP SDK with Jason Pearson

                                                                        Today we venture in the world of AI with Jason Pearson and the Android MCP (Model Context Protocol) SDK, a new library that allows Android developers to build apps that can communicate with AI models more effectively.

                                                                        While this library is still in its early days, this solution has a lot of potential to revolutionize how we interact and debug our Android apps. Jason is going to share insights from his with MCP and what it enables for Android developers: from layout inspections, to network debugging and potentially automating and simplifying UI testing for mobile apps!

                                                                        Enjoy the show 👨‍🍳

                                                                        Show Notes
                                                                        • 00.00 Intro
                                                                        • 00.46 Episode Start
                                                                        • 01.16 Jason’s Introduction
                                                                        • 02.02 What is the Android MCP SDK?
                                                                        • 04.36 MCP Use cases
                                                                        • 08.19 Shipping MCPs in production apps
                                                                        • 12.32 Installing the MCP SDK
                                                                        • 14.36 Project Maturity
                                                                        • 16.21 Building a new mental model
                                                                        • 22.45 What got into building an MCP server?
                                                                        • 25.24 How does the MCP protocol look like?
                                                                        • 29.36 Which APIs from the MCP spec have you implemented?
                                                                        • 31.18 What’s next for the Android MCP SDK?
                                                                        • 34.49 The future of AI
                                                                        • 40.42 Futher reading
                                                                        • 43.55 Where people can find you online?
                                                                        • Resources
                                                                          • kaeawc/android-mcp-sdk on GitHub
                                                                          • Official Project Documentation
                                                                          • Mentioned Resources:
                                                                            • Why MCP really is a big deal - Model Context Protocol with Tim Berglund
                                                                            • AI Code Assistants for Android Engineers
                                                                            • @kaeawc on GitHub
                                                                            • @kaeawc on Twitter
                                                                            • @kaeawc.bsky.social on Bluesky
                                                                            • Jason’s Personal Website
                                                                            • Show links
                                                                              • Podcast Website
                                                                              • The Developers’ Bakery on Spotify
                                                                              • The Developers’ Bakery on Apple Podcasts
                                                                              • The Developers’ Bakery on Google Podcasts
                                                                              • @thebakerydev on Twitter
                                                                              • @cortinico on Twitter
                                                                              • 47 min
                                                                              • Compose Hot Reload with Sebastian Sellmair

                                                                                Since it’s KotlinConf week we do have a special new episode for you folks! 🎁

                                                                                Today we have on stage Sebastian Sellmair, software engineer at JetBrains, and he’s here to talk about Compose Hot Reload.

                                                                                With Compose Hot Reload, you can make changes to your Jetpack Compose code and see the results instantly in your app without having to restart it! This means you can iterate faster and get immediate feedback on your changes, which is arguably a huge game-changer!

                                                                                In this episode, Sebastian will walk us through the story of this project, how it works internally, and why you need a custom JVM to make it work. He’ll also share some insights on how to test Hot Reload and what the future holds for this project.

                                                                                Enjoy the show 👨‍🍳

                                                                                Show Notes
                                                                                • 00.00 Intro
                                                                                • 00.46 Episode Start
                                                                                • 01.13 Sebastian’s Introduction
                                                                                • 01.58 In case you missed it: what is Jetpack Compose?
                                                                                • 03.39 What is Compose Hot Reload?
                                                                                • 10.06 How Hot Reload works?
                                                                                • 19.05 Watching for file changes
                                                                                • 25.57 The story of Hot Reload
                                                                                • 32.56 A custom JVM
                                                                                • 38.07 Testing Hot Reload
                                                                                • 43.09 Who will maintain Compose Hot Reload?
                                                                                • 46.05 Hot Reload inside Android Studio
                                                                                • 51.29 What’s next for Compose Hot Reload?
                                                                                • 53.54 Futher reading
                                                                                • 55.22 Where people can find you online?
                                                                                • Resources
                                                                                  • JetBrains/compose-hot-reload on GitHub
                                                                                  • @sellmair on GitHub
                                                                                  • @sellmair on Twitter
                                                                                  • Show links
                                                                                    • Podcast Website
                                                                                    • The Developers’ Bakery on Spotify
                                                                                    • The Developers’ Bakery on Apple Podcasts
                                                                                    • The Developers’ Bakery on Google Podcasts
                                                                                    • @thebakerydev on Twitter
                                                                                    • @cortinico on Twitter
                                                                                    • 57 min
                                                                                    • Bit with Gilad Shoham

                                                                                      We’re back with a fresh new episode! 🍞🎉

                                                                                      Today, we sit down with Gilad Shoham, Head of Engineering at Bit.dev

                                                                                      In this episode, Gilad will walk us through the fundamentals of Bit, how it enables composable architectures, and how development teams are using it as part of their workflow. We will touch on common challanges that developers are facing nowadays such as scaling teams, enabling them to be independent and move fast, while keeping the integration of the entire platform seamless.

                                                                                      We will also touch on the future of AI-assisted development and how Bit.dev fits in this bigger picture.

                                                                                      Enjoy the show 👨‍🍳

                                                                                      Show Notes
                                                                                      • 00.00 Intro
                                                                                      • 00.51 Episode Start
                                                                                      • 01.15 Gilad’s Introduction
                                                                                      • 02.41 What is Bit?
                                                                                      • 04.01 Composable Architecture
                                                                                      • 08.04 Bit & Harmony
                                                                                      • 13.21 Popular use cases for Bit
                                                                                      • 20.44 Sharing UI components
                                                                                      • 22.35 Dependency hell
                                                                                      • 28.20 Extending Bit beyond JavaScript
                                                                                      • 30.28 What is open source of bit.dev?
                                                                                      • 33.52 Who’s using bit.dev?
                                                                                      • 35.13 How bit.dev started?
                                                                                      • 37.31 Bit.dev & AI
                                                                                      • 47.44 Holistic AI
                                                                                      • 55.14 What AI of the future might look like
                                                                                      • 58.19 Futher reading
                                                                                      • 61.15 Where people can find you online?
                                                                                      • Resources
                                                                                        • teambit/bit on GitHub
                                                                                        • Bit.dev Official Website
                                                                                        • Bit.cloud Official Website
                                                                                        • Mentioned Resources
                                                                                          • @Bitdev Youtube Channel
                                                                                          • Bit Slack Workspace
                                                                                          • Gilad Personal Website
                                                                                          • @GiladShoham on GitHub
                                                                                          • @ShohamGilad on Twitter
                                                                                          • Gilad Shoham on LinkedIn
                                                                                          • Show links
                                                                                            • Podcast Website
                                                                                            • The Developers’ Bakery on Spotify
                                                                                            • The Developers’ Bakery on Apple Podcasts
                                                                                            • The Developers’ Bakery on Google Podcasts
                                                                                            • @thebakerydev on Twitter
                                                                                            • @cortinico on Twitter
                                                                                            • 1 hr 3 min

                                                                                            About The Developers' Bakery

                                                                                            From the publisher's feed

                                                                                            The Developers' Bakery is a podcast about developer tooling and the people who build and use it. Hosted by Nicola Corti, Marco Gomiero and Paolo Rotolo, the show alternates between two formats. In…

                                                                                            More shows like The Developers' Bakery

                                                                                            Decoder with Nilay Patel by The Verge

                                                                                            Decoder with Nilay Patel

                                                                                            3,154 Listeners