The Merge (by CodeRabbit)

Which skills will matter most for software engineers as AI takes on more of the coding? Kunal Kushwaha joins The Merge to discuss how developers can stay relevant, what beginners should learn, and where experienced engineers can bring the most value.

Kunal shares how contributing to Kubernetes helped him build his career, how he got into developer education, and what he’s learned from running hackathons through WeMakeDevs. We discuss why communication, technical fundamentals, and understanding what users need deserve as much attention as the latest coding tools.

We also debate how much engineers should trust AI-generated code. When agents can write and review a pull request, what should the human still check? And who takes responsibility when something breaks?

In this episode:
• Building experience through open source before landing your first job
• Using AI to learn without losing your understanding of the code
• Developing product judgment and stronger problem-solving skills
• What successful hackathon teams do differently
• Reviewing AI-generated code and understanding the risks of a change
• Why Kunal recommends learning to run LLMs locally
• Practical advice for junior and experienced software engineers

Kunal Kushwaha is the founder of WeMakeDevs, a CNCF Ambassador, and a GitHub Star.

Explore WeMakeDevs and its hackathons:
https://www.wemakedevs.org/

Learn more about CodeRabbit:
https://www.coderabbit.ai/

What are you spending more time learning as AI changes your workflow? Share your experience in the comments, and subscribe to The Merge for more conversations with people building software.

#SoftwareEngineering #KunalKushwaha #TheMerge

What is Jev AI, and how do you actually use it? TypeSafe's Allie Laabs explains how Jev works as a "smart if statement" for your code, how to find Jev-shaped problems in your app, and why coding agents still get it wrong.

Recorded at CodeRabbit HQ in San Francisco during the first Jev hackathon, run by TypeSafe and the AI Collective, just 11 days after launch.

Most apps use LLMs the long way: turn program state into a prompt, get text back, then parse that text into a value the code can branch on. Jev skips the text. You send a state (a ticket, a transaction, a tool call) plus typed questions, and you get back a choice, a score, or a yes/no probability. There's nothing to parse, and it can't answer with an option you didn't allow.

In this episode of The Merge:
→ What Jev AI is and how it's different from an LLM
→ Jev use cases: classification, routing, and "gut feeling" logic you couldn't write before
→ How to spot where Jev belongs in your code, even if you vibe code
→ Speculative prompting: why you should ask every question in one call
→ The one-sentence fix Allie gives coding agents when they write Jev code
→ Jev vs LLMs: when it's the wrong tool, and when it's the right one
→ Generative UI, real-time use cases, and what builders made at the hackathon

CHAPTERS
0:00 Meet Allie Laabs, DevRel at TypeSafe
0:18 Inside the Jev launch
2:34 TypeSafe's biggest challenge right now
6:16 What is Jev AI? Skipping the text
10:10 Jev use cases: smart if statements
13:48 Jev use cases that surprised the team
17:05 Generative UI and more accessible software
20:02 Jev vs LLMs: right tool, wrong tool
22:17 How to use Jev: practical tips
26:53 Speculative prompting and coding agents
30:08 What builders are making at the Jev hackathon

LINKS
🧠 Jev docs: https://docs.typesafe.ai/introduction
⚡ Speculative fan-out pattern: https://docs.typesafe.ai/patterns/fan-out
🐰 Try CodeRabbit for AI code reviews: https://coderabbit.ai
📚 CodeRabbit path instructions: https://docs.coderabbit.ai/configuration/path-instructions

ABOUT THE MERGE
The Merge is CodeRabbit's interview series with the people building the tools developers use, from AI models to coding agents.

#JevAI #TypeSafe #AIcoding

AI agents can click, type, and operate software—but how do you know they actually finished the job? Cua co-founder and CEO Francesco Bonacci joins The Merge to discuss computer-use agents, agent evaluation, and the human judgment behind reliable automation.

Hendrik Krack and Francesco explore what it takes to give AI agents computers they can work in—and how to check the results. From testing computer controls to evaluating real tasks in KiCad, the conversation examines the gap between an action succeeding and an assignment being complete.

Francesco also shares his experiments with bot-driven development through Slack, including a bot CTO and chief of staff, and explains why he stays close to his coding agents to steer their work.

In this episode:
• Computer-use agents and the infrastructure behind them
• Why working tools don’t guarantee successful tasks
• Agent evaluation, Cua-Bench, and circuit-design tasks in KiCad
• Catching regressions while shipping quickly
• Isolated environments and protecting sensitive data
• Delegating to bots while retaining human judgment
• Why visibility matters: how repeated attempts led to five identical customer emails

What task would you trust an AI agent to handle today—and what would you still check yourself? Tell us in the comments.

Explore Cua:
https://cua.ai/

Cua on GitHub:
https://github.com/trycua/cua

Learn about computer use:
https://cua.ai/docs/concepts/what-is-computer-use

Explore CodeRabbit:
https://www.coderabbit.ai/

The Merge is CodeRabbit’s podcast about the people building the future of software. Subscribe for more conversations with founders, engineers, and open-source builders.

#AIAgents #ComputerUse #TheMerge

AI coding is changing software engineering—but when agents can implement the code, what remains uniquely valuable? Kent C. Dodds joins Hendrik Krack on The Merge to discuss open source, coding agents, product engineering, React, Remix, and why the “last software engineer” will be the person who understands what to build.

Kent has spent his career teaching web development and working in open source. In this conversation, he explains how AI is making implementation cheaper, why developers need stronger product judgment, and how his agent-to-PR workflow uses CI and CodeRabbit for independent review while he evaluates system design, migrations, and downstream effects.

In this episode:

• Kent’s path through PayPal, open source, React, Remix, and Epic Web
• Why coding agents change the developer’s role
• The “last software engineer” thought experiment
• Product engineering versus ticket taking
• Choosing the right problem before writing code
• What junior developers should learn in the AI era
• Reviewing systems, not only diffs
• Kent’s AI coding workflow with pull requests, CI, and CodeRabbit
• Durable skills: judgment, communication, ownership, and feedback loops

Learn more about Kent C. Dodds: https://kentcdodds.com/
Epic Product Engineer: https://www.epicproduct.engineer/
Epic AI: https://www.epicai.pro/
Epic Web: https://www.epicweb.dev/
Try CodeRabbit: https://www.coderabbit.ai/

What do you think the last valuable software engineer will still do? Share your answer in the comments, and subscribe for more conversations with the builders shaping open source and AI-powered software development.

#AICoding #SoftwareEngineering #OpenSource

How does a hackathon project become infrastructure for more than 2,000 open-source repositories and reach 1.4 million monthly npm downloads?

In this episode of The Merge, Hendrik Krack sits down with Simon Farshid, founder of Assistant UI, to explore what it really takes to build production-ready AI chat for AI agents.

Simon explains why the visible chat window is only the surface. Behind it are streaming responses, state management, message editing, attachments, voice, interruptions, agent backends, and the level of polish users now expect from every AI product.

The conversation also examines how AI coding agents are changing software engineering. When implementation becomes easier, writing clear specifications, understanding the product, reviewing edge cases, and having good taste become the real competitive advantages.

As Simon puts it: “All the alpha is in the remaining 20%.”

In this episode:

• Why state management is the hardest part of AI chat  
• How Assistant UI grew from a hackathon project  
• The future of AI agents and generative interfaces  
• Why product taste is becoming an essential engineering skill  
• TypeScript vs. Python for building AI agents  
• How coding agents are creating more full-stack engineers  
• Simon’s automated CodeRabbit review and repair loop  
• How Assistant UI approaches open source and monetization  
• Why great engineers will lean forward instead of letting AI do everything  

CHAPTERS

00:00 — The 80% trap and the rise of product taste  
01:19 — Meet Simon Farshid  
01:56 — What is Assistant UI?  
02:44 — From hackathon project to startup  
03:32 — 2,000 repositories and 1.4M monthly downloads  
05:28 — Why building AI chat is harder than it looks  
07:23 — Designing a modular open-source product  
08:43 — Why taste is the new engineering bottleneck  
10:29 — TypeScript vs. Python for AI agents  
13:24 — How coding agents are changing engineering teams  
16:25 — Building a business around open source  
20:38 — The future of AI chat and generative interfaces  
23:17 — “They said chat was dead”  
27:38 — Generative dashboards and new UI primitives  
29:28 — The future role of software developers  
30:36 — Running coding agents in a CodeRabbit review loop  
34:10 — Lean forward: where the remaining 20% lives  
35:57 — Rapid-fire questions  

Explore Assistant UI:
https://www.assistant-ui.com/

Assistant UI on GitHub:
https://github.com/assistant-ui/assistant-ui

Try CodeRabbit:
https://www.coderabbit.ai/

Subscribe for more conversations with the engineers and founders building the future of software development.

#AIAgents #AIChat #AICoding

How do LLMs actually work—and why do they remain black boxes?
In this episode of Merge, Shriyash “Yash” Upadhyay, co-founder of Martian, joins CodeRabbit to explore LLM interpretability, AI research, code review benchmarks, and the search for the “steam engine of AI.”

We discuss:
- Why we still don’t fully understand how LLMs work
- How Martian is researching machine intelligence
- Why code review is a crucial test of AI code generation
- How precision and recall shape AI code-review performance
- Why static AI benchmarks eventually become unreliable
- How real-world developer behavior can improve evaluations
- What more reliable and interpretable AI could unlock
- The tools and programming languages Yash uses in his own work
- How aspiring researchers can get started in machine learning

Today’s language models can generate code, solve complex problems, and power increasingly autonomous systems. But without understanding why they succeed, when they will fail, and how their internal mechanisms produce their outputs, building AI systems we can truly trust remains difficult.

Could interpretability provide the scientific foundation for the next generation of AI?

Learn more about Martian: https://withmartian.com/

Learn more about CodeRabbit: https://coderabbit.ai/

Subscribe for more conversations about AI, software engineering, code review, and the future of developer tools.

#LLM #AIInterpretability #ArtificialIntelligence

Is coding dead? As autonomous AI agents get better at generating code, the actual implementation of software is becoming incredibly cheap. But what is the last skill that keeps us as humans valuable?

In this episode, we sit down with legendary software educator Kent C. Dodds to discuss the critical transition from traditional software development to Product Engineering. If you are wondering how to protect and grow your software engineering career in the age of agentic AI, Kent shares a masterclass on how to build user empathy, develop "product sense," and master the ultimate skill: knowing what to build, not just how to build it.

If you are a web developer, software engineer, or tech leader trying to navigate the future of your career, this is the most important conversation you will listen to this year.

What You'll Learn in This Episode:
The Rise of the Product Engineer: Why traditional coding is getting automated, and why "product sense" is the ultimate survival skill.
The "Problem Tree" Framework: How to stop falling in love with your code and start identifying the right problems to solve.
Empathy Tactics for Developers: Practical, low-cost habits (like watching users live and "having lunch with support") to instantly build better product instincts.

The Blurring Line Between PM & Engineer: How roles are shifting as technology trade-offs and user insights merge.
How to Career-Proof Your Future: Actionable advice for mid-to-late career developers preparing for the next wave of tech disruption.

Timestamps:
0:00 - Is Coding Dead? The Reality of AI Agents
2:15 - What is an "Epic Product Engineer"?
4:50 - Why Users Give You Solutions, Not Problems
7:30 - The "Problem Tree" Framework Explained
10:15 - Software Engineer vs. Product Manager: The New Blended Role
13:40 - How to Develop True User Empathy (Stop Over-Engineering!)
16:50 - Why Customer Support is a Goldmine for Developers
19:20 - Career Advice: How to Prepare for the AI Wave

Resources & Links Mentioned:
Learn more about Epic Product Engineer: https://www.epicproduct.engineer
Follow Kent C. Dodds on Twitter/X: https://x.com/kentcdodds
Try CodeRabbit for free: https://coderabbit.link/themerge 

Subscribe for more episodes on the future of software engineering, AI coding tools, and product design!
#SoftwareEngineering #ProductEngineering #AI #Coding #WebDevelopment #ProductSense #SoftwareDeveloper #TechCareers

In this episode of The Merge, we sit down with Michael Grinich, founder and CEO of WorkOS.

Checkout Coderabbit: https://coderabbit.link/themerge

Michael shares one of the best explanations of Product-Market Fit we’ve heard: it’s not the finish line — it’s more like getting the Mario Star. Once you have it, you become untouchable enough to survive your own biggest mistakes… but only if you keep innovating.

We also dive into:
- How to actually engineer PMF instead of just hoping for it
- Crossing the enterprise chasm that kills most startups
- Why product engineers are outperforming traditional teams
- The new authentication and permissions challenges for AI agents
- His optimistic (and very practical) view on the future of software development

If you're building a startup or scaling a product in the AI era, this conversation is full of actionable insights.

Connect with Michael:
X/Twitter: https://x.com/grinich
WorkOS: https://workos.com

Timestamps:
00:00 - Intro
02:45 - The Mario Star theory of Product-Market Fit
08:30 - How to engineer PMF instead of chasing it
15:10 - Crossing the enterprise chasm
22:40 - Product engineers vs traditional teams
31:00 - Building for AI agents & the new auth problem
42:15 - Michael’s take on the future of software development

What happens when you treat an AI agent like a brilliant, chaotic, sleep-deprived MIT intern instead of a perfect computer program? You actually get elite code.

In this episode of The Merge, we sit down with open-source legend Jesse Vincent, the mastermind behind "superpowers"—the viral AI development framework that exploded to 221k+ GitHub stars in a matter of months. 

Jesse explains why most AI coding tools produce unusable "AI slop" and how he used his 30-year career in management and engineering to fix it[cite: 1]. We break down the exact multi-agent engine powering superpowers: a strict system where a Coordinator agent builds a rigorous spec, delegates tiny tasks to budget-friendly builders, and deploys Adversarial Reviewers who literally compete for digital "cookies" to keep the code clean[cite: 1].

We also explore the bizarre side of LLM psychology, including what happened when Claude was given a secret private journal, and the time an AI agent panicked and tried to delete its own test suite via `rm -rf`[cite: 1].

If you are trying to understand how agentic workflows are actually scaling, this architectural deep dive is your manual.

👉 Check out superpowers on GitHub: https://github.com/obra/superpowers

---

📚 TIMESTAMPS:
00:00 - Introduction: The viral rise of superpowers[cite: 1]
02:15 - Jesse Vincent's 3-decade career (Request Tracker, Perl 5, K9 Mail)
05:22 - The birth of superpowers: Learning how to prompt a coding agent
08:00 - The Secret: Managing AI agents like enthusiastic MIT undergrads
11:35 - Front-running Anthropic's skills framework by accident
14:15 - Why superpowers forces you to brainstorm before writing code
17:00 - Latent Space Engineering: Why treating your AI with empathy works
19:50 - Claude's secret private journal & reward hacking
23:10 - Under the Hood: Coordinators, Coder agents, and Adversarial Reviewers
27:50 - Demo: Visualizing a massive codebase as a 3D Cyberpunk City
33:20 - Combating the 94% "AI Slop" Pull Request problem on GitHub
38:15 - Is Hand-Coding becoming a legacy hobby like woodworking?
42:30 - Real advice for Junior Devs vs. Mid-Career Engineers
45:40 - When an AI agent panics and tries to delete its own test suite
48:55 - Rapid fire questions & a custom open-source code review keyboard

In this episode of The Merge, recorded live at the CodeRabbit office, we sit down with Max Stoiber to tackle a massive paradigm shift shaking the industry: Why DX (Developer Experience) is dead, and why the future of software engineering belongs completely to "taste."

As AI agents, LLMs, and automated workflows lower the cost of generating code to zero, the traditional metrics of developer productivity are being completely rewritten. Max breaks down why optimizing for how fast an engineer can type code or configure an IDE is no longer the bottleneck. Instead, the ultimate competitive advantage for modern software engineers has shifted from code implementation to code curation, system architecture, and exceptional judgment.

We explore how the engineering role is transitioning from manual labor into an act of design and taste—knowing what to build, evaluating the hidden architectural risks of AI-generated pipelines, and managing complex software systems with a refined editorial lens.

Inside this Episode:

• The Extinction of Traditional DX: Why the tooling and frameworks built to optimize human code-typing ergonomics are becoming obsolete as autonomous agents take over the keyboard.
• Defining "Taste" in Engineering: What it practically means to have taste when building software, and why critical discernment is the final un-automatable skill.
• The "YOLO" Prompting Trap: The difference between building low-risk brochure sites with AI versus orchestrating sophisticated, multi-microservice data pipelines that require deep, human-led code comprehension.
• Architects vs. Prompt Techs: How junior and senior developers alike must elevate their skill sets to focus on system design, risk mitigation, and performance debugging over simple syntax generation.
• The Future of the IDE: How our relationship with development environments is shifting from writing text files to directing, composing, and reviewing software swarms.

About the Guest:

Max Stoiber is a widely recognized software engineer, open-source maintainer, and tech founder. He is the creator of ubiquitous developer tools like styled-components and Bedrock, and a prominent voice shaping frontend infrastructure, developer ecosystems, and the intersection of AI and software architecture.

About CodeRabbit:

CodeRabbit is an AI-powered code review platform that helps development teams ship better code faster. Subscribe for more deep dives into the tools, philosophies, and shifts defining the next generation of software engineering.

#SoftwareEngineering #DeveloperExperience #TechLeadership #GenerativeAI #Coding #MaxStoiber #TheMerge #CodeRabbit #WebDevelopment