Modern Web

In this episode of the Modern Web Podcast, Rob Ocel, Danny Thompson, and Adam Rackis sit down with Ahmad Awais, CEO and founder of LangBase, to talk about agents, context, and the future of AI-assisted software development. Ahmad shares the origin story of Chai.new, an agent that builds agents, and why he believes context, not code, is the true value layer in the AI era. The group unpacks how "vibe coding" is reshaping who can build software, why Chai isn’t just another AI assistant, and how agents might evolve into personalized, production-grade tools for everyone, technical or not. Plus: Tailwind analogies, Stanford lectures, sports nutrition agents, and a CLI that went viral in a hospital.Key points from this episode:- Ahmad Awais explains that AI agents aren't magic; they're just a new paradigm for writing software. What makes them powerful is their ability to act autonomously with relevant context, not just generate text.- Chai.new helps developers (and non-developers) create purpose-built agents without needing deep ML expertise. It abstracts complex concepts like memory, retrieval, and orchestration into an approachable interface.- Ahmad emphasizes that the real opportunity lies in agents tailored to individual users and use cases. Personal agents with custom context outperform generic ones, much like small teams beat massive frameworks for specific problems.- Chai and LangBase aim to bring AI development to the millions of engineers who aren't AI researchers. With tools like Chai, you don’t need a PhD to build powerful, production-ready AI agents.Follow Ahmad Awais on Social MediaTwitter: https://x.com/MrAhmadAwaisLinkedin: https://www.linkedin.com/in/mrahmadawais/Sponsored by This Dot: thisdot.co

In this episode of the Modern Web Podcast, Danny Thompson sits down with Reed Harmeyer, CTO of Skylight Social, and Brandon Mathis, React Native engineer at This Dot Labs. They unpack the technical and strategic decisions behind Skylight’s meteoric growth: why they built on the AT Protocol, how they tackled video discovery and scaling challenges, and how a fast-tracked in-app video editor gave them an edge.Keypoints from this episode:Skylight Social was built on the AT Protocol, allowing users to retain followers across platforms like Blue Sky and enabling creators to publish interoperable content in a decentralized social network.The team used React Native with Expo to achieve rapid development and cross-platform performance—launching a high-quality, TikTok-like video experience in just days.An in-app video editor was prioritized to reduce friction for creators, built using a native SDK wrapped with Expo Modules, enabling features like clip rearranging, overlays, voiceovers, and AI-generated captions.User behavior data—specifically watch time—drives content recommendations, not just likes or follows, helping Skylight offer a personalized experience while navigating scaling challenges from hypergrowth.Follow Reed Harmeyer on Social MediaBluesky: https://bsky.app/profile/reedharmeyer.bsky.socialLinkedin: https://www.linkedin.com/in/reed-harmeyer/

In this episode of the Modern Web Podcast, Rob Ocel and Danny Thompson sit down with Julián Duque, Principal Developer Advocate at Heroku, to talk about Heroku’s evolution into an AI Platform-as-a-Service. Julián breaks down Heroku’s new Managed Inference and Agents (MIA) platform, how they’re supporting Claude, Cohere, and Stable Diffusion, and what makes their developer experience stand out.They also get into Model Context Protocols (MCPs)—what they are, why they matter, and how they’re quickly becoming the USB-C for AI. From internal tooling to agentic infrastructure and secure AI deployments, this episode explores how MCPs, trusted environments, and better AI dev tools are reshaping how we build modern software.Key Points from this episode:- Heroku is evolving into an AI Platform-as-a-Service with its new MIA (Managed Inference and Agents) platform, supporting models like Claude, Cohere, and Stable Diffusion while maintaining a strong developer experience.- MCPs (Model Context Protocols) are becoming a key standard for extending AI capabilities—offering a structured, secure way for LLMs to access tools, run code, and interact with resources.- Heroku's AI agents can perform advanced operations like scaling dynos, analyzing logs, and self-healing failed deployments using grounded MCP integrations tied to the Heroku CLI.- Despite rapid adoption, MCPs still have rough edges—developer experience, tooling, and security protocols are actively improving, and a centralized registry for MCPs is seen as a missing piece.Chapters0:00 – What is MCP and why it matters3:00 – Heroku’s pivot to AI Platform-as-a-Service6:45 – Agentic apps, model hosting, and tool execution10:50 – Why REST isn’t ideal for LLMs14:10 – Developer experience challenges with MCP18:00 – Hosting secure MCPs on Heroku23:00 – Real-world use cases: scaling, healing, recommendations30:00 – Common scaling challenges and hallucination risks34:30 – Testing, security, and architecture tips36:00 – Where to start and final advice on using AI tools effectivelyFollow Julián Duque on Social MediaTwitter/X: https://x.com/julian_duqueLinkedin: https://www.linkedin.com/in/juliandavidduque/Sponsored by This Dot: thisdotlabs.com

In this episode of the Modern Web Podcast, Rob Ocel and Danny Thompson talk with Hannes Rudolph, Community Manager at RooCode, to explore how this fast-moving, community-driven code editor is rethinking what AI-assisted development looks like. Hannes breaks down Roo’s agentic coding model, explains how their “boomerang tasks” tackle LLM context limits, and shares lessons from working with contributors across experience levels.Keypoints from this episode:- RooCode's "boomerang" architecture breaks complex coding tasks into structured, recursive subtasks, helping AI agents stay focused while avoiding context bloat and hallucination chains.- Developers can build their own orchestrator and agent modes in Roo, tailoring persona and instructions to fit specific workflows—crucial for long-term productivity.- Unlike many tools, RooCode shows developers exactly how much each LLM call costs in real time, empowering teams to manage both quality and budget.- RooCode is deeply community-driven, with user-submitted PRs frequently reshaping priorities. The team emphasizes transparency, collaboration, and accessibility for contributors at all levels.Follow Hannes Rudolph on Linkedin: https://www.linkedin.com/in/hannes-rudolph-64738b3b/Sponsored by This Dot: thisdotlabs.com

In this episode of the Modern Web Podcast, Rob Ocel is joined by Danny Thompson, Adam Rackis, and special guest Coston Perkins for a lively discussion on the evolving role of AI in software development. The group swaps thoughts on everything from the rise of AI agents like RooCode and Claude, to what makes tools like Vercel’s v0 surprisingly powerful for frontend work. They debate Tailwind’s dominance as the styling output of choice for AI tools, unpack the implications of Shopify’s AI-mandate memo, and tackle the big question: will AI reshape team structures or just amplify developer productivity?Keypoints from this episode:- AI agents in everyday development – The hosts discuss how tools like RooCode, Claude, and Cursor are reshaping daily coding workflows, enabling everything from automated documentation to feature planning and refactoring.- Vercel's v0 is changing perceptions – Originally seen as a landing page generator, v0 is now appreciated for its live, code-focused interface, showing promise for serious frontend development with real-time editing and deployment.- Tailwind’s dominance in AI output – The conversation dives into why Tailwind has become the styling default for AI-generated components, and whether that’s a productivity boost or a future limitation.- AI’s impact on hiring and team structure – The group debates whether AI will reduce developer headcount or empower mid-level devs to produce senior-level output—suggesting AI may reshape team dynamics more than replace them.Follow Coston Perkins on Linkedin: https://www.linkedin.com/in/costonperkins/Sponsored by This Dot: thisdot.co

In this episode of the Modern Web Podcast, host Danny Thompson and co-host Adam Rackis chat with James Perkins, CEO of Unkey, an open-source API management platform built for scale, security, and developer simplicity. James shares the challenges of building globally distributed infrastructure, and why his team ditched serverless and TypeScript in favor of Go and servers.They talk candidly about the realities of API management at scale, how Unkey balances open source transparency with enterprise-grade performance, and what it takes to build developer trust—both as a brand and as a product.Keypoints from this episodeUnkey simplifies API management by acting as middleware for authentication, rate limiting, and security—without requiring deep backend expertise. It's designed for developers to go from idea to production with minimal setup.Go over serverless – James and his team initially explored TypeScript and serverless architecture but ultimately returned to Go and servers for better performance, scalability, and developer experience at scale.Open-source transparency is core to Unkey’s philosophy – The entire codebase is public, and the team maintains a radically open company culture, where even investor updates and customer support emails are shared internally.Customer obsession drives every decision – Regardless of whether a user is paying $0 or $2,000/month, Unkey responds quickly, prioritizes community support, and encourages a culture of ownership and responsiveness across the team.Chapters00:00 – Intro + Why Unkey exists02:00 – James' background and API pain points03:50 – What Unkey actually does05:45 – Engineering challenges + scaling architecture07:30 – Tech stack changes: Go, TypeScript, Serverless08:45 – Unkey as middleware: auth, rate limiting, analytics10:40 – Future vision: making APIs as easy as deploying on Vercel11:45 – Why Go instead of Node or TypeScript13:30 – Go vs TypeScript: hiring, dependencies, developer experience15:00 – Why API management is hard at scale17:15 – Case study: Fireworks and Google Apigee performance issues19:00 – The complexity of modern API platforms20:00 – Sponsor break: This Dot Labs20:35 – Will Unkey expand into app hosting?22:00 – Unkey's focus on doing one thing really well23:45 – Content strategy: personal brand vs corporate marketing26:20 – Customer obsession: internal culture and open company model30:30 – Open source dynamics and being fully transparent33:45 – Advice for developer-entrepreneurs36:24 – Wrap up + where to find the speakersFollow James Perkins on Social MediaTwitter/X: https://x.com/james_r_perkinsBlue Sky: https://bsky.app/profile/jamesperkins.devUnkey: https://www.unkey.com/Sponsored by This Dot: thisdot.co

In this episode of the Modern Web Podcast, Rob Ocel and Danny Thompson talk with Corbin Crutchley — founder of Playful Programming, Microsoft MVP, GitHub Star, and maintainer of multiple TanStack libraries including TanStack Form, Store, and Config.They dive into Corbin’s work maintaining open source at scale, what makes TanStack Form different (and a bit esoteric), and why the design decisions behind it matter, especially for enterprise teams. They also unpack the tradeoffs of abstraction, type safety in large-scale apps, and best practices for migrating form logic.Later in the episode, the conversation shifts to Corbin’s nonprofit and developer education philosophy: why Playful Programming focuses on deep conceptual understanding over task-based tutorials, how AI is changing how people learn, and what’s next for guiding developers from beginner to intermediate and beyond.Key points from this episode:– Corbin explains how TanStack Form’s architecture, though verbose and esoteric, enables strong type safety, SSR support, and integration with modern frameworks like Next.js and Remix.– The group discusses common pain points in migrating from other form libraries, especially around type inference and validation layers, and how TanStack Form encourages a clean separation of concerns.– Maintaining open source at scale requires balancing community feedback with a strong guiding philosophy; Corbin highlights the importance of civility and staying true to the project’s design principles.– Playful Programming focuses on deep, conceptual education over task-based tutorials, aiming to help learners move from beginner to intermediate with free, accessible content and personalized learning in the future.Chapters0:00 – Why TanStack Form Is Built This Way1:06 – Meet Corbin Crutchley and the TanStack Ecosystem3:34 – How Corbin Joined and Shaped TanStack Form6:17 – Why Use TanStack Form (Despite the Verbosity)10:28 – Type Safety, Generics, and Enterprise-Ready Patterns14:50 – Validation Best Practices and SSR Integration18:45 – Handling Feedback in Open Source21:22 – Playful Programming: Teaching Concepts Over Tasks27:33 – Bridging the Developer Education Gap35:54 – Is It Still Worth Learning Programming?38:25 – The Evolving Role of Developers and Soft Skills41:57 – Wrap-Up and Where to Connect OnlineFollow Corbin Crutchley on Social MediaLinkedin:   https://www.linkedin.com/in/corbincrutchleyX/Twitter: https://x.com/crutchcornSponsored by This Dot: thisdot.co

Ben Peeri, Lead Solutions Architect and entrepreneur, shares his expertise on the evolving landscape of AI tools in software development. He discusses the strengths and limitations of platforms like v0, Bolt, and Replit. Ben reveals his innovative use of local LLMs for secure pen testing and emphasizes the need for effective prompting strategies. He also highlights the changing role of junior developers, urging them to adapt by refining AI-generated code rather than starting from scratch, fundamentally shifting how teams approach building software.

In this episode of the Modern Web Podcast, Rob Ocel and Danny Thompson get real about the current state of AI in software development. They talk about what’s working, what’s frustrating, and why so much of the conversation around AI feels repetitive or disconnected from reality. They explore how AI is actually being used day to day—and where it still falls short. They also discuss the risks of relying too heavily on AI, especially for junior devs, and why understanding fundamentals still matters. Keypoints from this episode:- AI fatigue is setting in among developers, with many eager to move beyond hype and explore tools that solve real problems and deliver everyday value.- Danny built a conversational AI agent named Nexie, trained specifically on Next.js and Vercel documentation, showing how personalized agents can provide focused, meaningful assistance.- Over-relying on AI can backfire for junior developers. Using it to generate code without understanding the underlying logic undermines learning and growth.- AI tools are starting to shift how we think about software quality. In some cases, speed and cost-effectiveness may outweigh traditional goals like maintainability.Chapters00:00 – Should Juniors Use AI?01:04 – Real Talk on AI Conferences03:00 – Building Nexi: A Personal Dev Agent05:13 – Beyond the Hype: Finding Real AI Use Cases09:36 – Why Senior Devs Struggle with AI Tools15:55 – Mentorship, Theory, and Learning the Right Way21:10 – When to Use AI (and When Not To)26:50 – The Growing Gap in Dev Skills30:31 – AI Is Redefining “Good Software”32:09 – Final Thoughts + Where to Find UsFollow This Dot Media on Twitter/X: x.com/thisdotmediaFollow Danny and Rob on Twitter.Sponsored by This Dot: thisdotlabs.com

Join hosts Rob Ocel and Danny Thompson for another episode of the Modern Web Podcast, where they sit down with Brad Garropy, senior front-end engineer at Stripe, YouTuber, and all-around tech enthusiast.Brad shares insights from his journey through big tech—from Dell to Adobe, Atlassian, and now Stripe—while discussing the challenges of scaling front-end engineering across different companies. The conversation covers TypeScript’s major performance boost, the Go vs. Rust debate, and how engineering teams are evolving their tooling for speed and efficiency.They also explore Remix, why Brad prefers building projects with minimal dependencies, and his approach to self-hosting and keeping costs low for side projects. He reflects on balancing breadth vs. depth in a career, how developers can shape their personal brand, and the importance of learning through building.Key Points from this Episode:- TypeScript’s shift to Go has resulted in massive performance improvements, highlighting the impact of language choice on tooling speed and efficiency.- Scaling front-end engineering in big tech comes with unique challenges, and each company operates differently despite similarities in structure.- Keeping projects lean with minimal dependencies and self-hosting can reduce costs and provide greater control over development.-Balancing breadth vs. depth in a career is crucial, as developers must decide whether to specialize deeply or explore a wide range of technologies.Chapters0:00 – Intro: Tailwind, Remix, and Thin Abstractions1:09 – Meet the Hosts & Guest: Brad Garrapy2:16 – Brad’s Career Journey: Dell → Adobe → Atlassian → Stripe3:34 – TypeScript Gets 10x Faster: Why Go?7:55 – Performance, Tooling, and Multi-threading Insights14:59 – Why Remix? Building with Thin, Flexible Stacks16:56 – Deployment Strategies & Avoiding SaaS Lock-in19:57 – Cost, Free Tiers & the Case for DIY Infrastructure28:13 – Creator Goals: Streaming, Tutorials & Building in Public33:12 – Identity, Community, and Being Known for Something38:23 – Where to Find Brad Online + ClosingFollow Brad Garropy on Social MediaYouTube - https://youtube.com/bradgarropyBluesky - https://bradgarropy.com/blueskyTwitter - https://x.com/bradgarropyWebsite - https://bradgarropy.comSponsored by This Dot: thisdot.co