Distributed.

How does the future hold for software development with remote collaboration?

In this episode of the Distributed podcast, host Jack Hannah chats with Tim Ottinger, aka the Agile Otter, about how to manage and organize the work. Among other things, Tim is a Senior Consultant at Industrial Logic, contributor to the book Clean Code, and active presence online. Jack and Tim explore various ways to work in teams instead of solo and the various benefits they offer.

Highlights:

• Rethinking solo work to boost first-time through rates and productivity 
• Tim’s experiences with Extreme Programming and Agile 
• Introducing swarm boards  for better remote teamwork 

In this episode, we cover:

(00:00) – Introduction to Tim Ottinger, Agile Otter

(01:11) – Tim’s background and contributions to clean code and agile

(01:46) – Early remote work and why covid changed remote training

(04:03) – Benefits of spreading training over weeks vs. intense sessions

(06:18) – What’s wrong with how most software teams manage work today

(10:42) – The problems with solo work, parallelism, and utilization myths

(14:14) – How AI can help coding but still has limitations

(18:07) – Why increasing first time through rate is the key metric

(24:18) – How to structure teams to avoid queues and handoffs with swarm boards

(30:50) – Starting with small experiments to work together and improve flow

(33:12) – Don’t lower the standards of the pipeline, raise the abilities of the team

(40:07) – When it comes to remote work, longitude kills and latitude hurts

(41:38) – Tim’s advice for making the most out of remote work

(44:05) – The law of the 2nd floor

(44:51) – Things can be better, don’t lose hope

References

Swarm Programming with the Swarm Board

Clean Code by Robert C. Martin

Where to connect further:

Connect with Tim Ottinger on LinkedIn and on his website

Connect with Industrial Logic

Follow Tuple

Want to hear more? Check out distributed.fm

Connect with Jack Hannah

In this episode of Distributed, host Jack Hannah speaks with Emily Bache, a technical coach and the creator of Samman Coaching, about her work helping teams improve their development practices. 

Emily shares her experiences with test-driven development and refactoring, and explains how these practices can transform both code quality and team dynamics.

Highlights:

• The impact of test-driven development on software quality
• How to introduce new practices in a resistant environment
• Why collaborative coding, like ensemble programming, accelerates team growth
• The role of leadership in creating a culture of continuous learning and quality

In this episode, we cover:

(00:00) – Kicking things off with Emily Bache

(01:25) – First experience with extreme programming in 2000

(02:28) – Struggling to get a new team on board with XP

(04:03) – Why TDD transformed Emily’s coding approach

(05:22) – Becoming a full-time technical coach and YouTuber

(06:48) – Defining what a technical coach actually does

(07:21) – Inside a high-performing architecture team’s microservices shift

(09:04) – Can siloed experts still outperform collaborative teams?

(14:42) – Simple tactics to nudge your team toward better practices

(20:57) – Ensemble programming explained: many minds, one keyboard

(24:45) – Why refactoring skills matter in the age of AI assistants

References

Approval Tests and the weekly Approval Tests Ensemble

ChatGPT & Copilot are NOT Refactoring Tools

Where to connect further:

Connect with Emily Bache on LinkedIn and Samman Technical Coaching Society

Follow Tuple

Want to hear more? Check out distributed.fm

Connect with Jack Hannah

In this episode of the Distributed podcast, Jack Hannah sits down with Matt Wynne, staff software engineer at Mechanical Orchard and a longtime advocate for Agile and Behavior-Driven Development (BDD). Matt shares his journey from working with legacy systems to co-founding Cucumber Ltd., offering a firsthand look at how testing, pairing, and social programming create more effective teams.

Matt also discusses the challenges of modernizing outdated infrastructure, the role of ensemble programming in fostering collective code ownership, and why strong relationships are essential for high-functioning distributed teams.

Highlights:

• The power of social programming: how pairing and ensembling improve collaboration and knowledge-sharing
• The evolution of BDD and its impact on software development
• Strategies for handling legacy modernization projects with minimal disruption
• Why creating psychological safety leads to stronger remote teams and better engineering outcomes
• The future of automation, AI, and the next wave of innovation

In this episode, we cover:

(00:00) - Kicking things off with Matt Wynne

(00:13) - From COBOL to modernization: Lessons in legacy systems

(05:05) - The origins of Cucumber and BDD

(07:44) - Pairing, ensembling, and the power of social programming

(11:38) - Extracting knowledge from aging codebases

(14:07) - Building tools for faster legacy system migrations

(21:01) - Creating psychological safety in engineering teams

(29:19) - Selling change: How to introduce new development practices

(33:02) - Remote work and the importance of human connection

References

Working Effectively with Legacy Code by Michael Feathers

Agile Coaching by Rachel Davies and Liz Sedley

Where to connect further:

Connect with Matt Wynne on LinkedIn and his Website

Follow Tuple

Want to hear more? Check out distributed.fm

Connect with Jack Hannah

In this latest episode of the Distributed podcast, host Jack Hannah interviews Colin Sidoti, Clerk Cofounder & CEO, to discuss what’s allowed them to grow so rapidly and deliver such an incredible developer experience for users. Colin reflects on how limited process fosters growth and allows his team of engineers and designers to excel.

Colin also provides insight into the nontraditional ways Clerk streamlines work, including their hiring practices and unique team dynamics.

Highlights:

• Understanding how Clerk has grown through a highly autonomous team culture
• Colin's insights on the importance of fluid communication in a distributed team
• The pivotal role the DX Guide plays in creating an amazing product
• Empowering teams by trusting their instincts and encouraging adaptability

In this episode, we cover:

(00:00) – Kicking things off with Colin Sidoti

(03:26) – Product development at Clerk

(08:29) – Remote work dynamics: synchronizing across time zones

(12:54) – Importance of fluid communication: using Tuple for efficient syncs

(14:44) – The role of DX Guide: maintaining high standards in product experience

(22:28) – Building a culture of customer-centric development

(17:40) – Evolving product offerings: from auth to billing and beyond

(25:56) – Hiring for passion: finding team members who care deeply

(31:55) – Simplifying user onboarding: eliminating friction for developers

(33:34) – Impact of removing friction: boosting adoption with minimal steps

Where to connect further:

Connect with Colin Sidoti on X and Clerk

Follow Tuple

Want to hear more? Check out distributed.fm

Connect with Jack Hannah

Engineering teams whose work leaves an impact thrive on trust, collaboration, and the appropriate technical practices.

In this episode of the Distributed podcast, host Jack Hannah sits down with Ryan Bergman, Principal Engineer at John Deere, to explore the impact of Extreme Programming (XP) and agile practices on software development. Ryan shares how XP principles helped stabilize a struggling startup, why pair programming is essential for team cohesion, and how behavior-driven development (BDD) builds confidence in large-scale systems.

They also discuss the challenges of remote collaboration, lessons from scaling software at John Deere, and what it takes to align distributed teams around a shared technical vision.

Highlights:

• Rescuing a struggling startup by embracing Extreme Programming to improve collaboration, code quality, and technical execution
• Strengthening engineering teams with pair programming and the right balance of structure and flexibility
• Managing large-scale software development at John Deere
• Building trust across distributed teams through clear communication, shared technical vision, and an emphasis on psychological safety
• Using Behavior-Driven Development (BDD) to create reliable, well-tested systems that give teams confidence in their software

In this episode, we cover:

(00:00) – Kicking Things Off with Ryan Bergman

(01:10) – Ryan’s Journey: From Graphic Arts to Engineering

(03:59) – Discovering XP: How Extreme Programming Saved a Startup

(08:09) – Pair Programming and Agile Coaching: Rebuilding from the Ground Up

(14:14) – Navigating Large-Scale Systems at John Deere

(16:22) – The Power of Trust: Autonomy, Collaboration, and ‘Vampire Rules’

(21:37) – Building Strong Engineering Teams Through Open Knowledge Sharing

(26:49) – Pair Programming Pitfalls: Fixing What Doesn’t Work

(37:11) – Behavior-Driven Development: Creating Confidence in Complex Systems

Where to connect further:

Connect with Ryan Bergman on LinkedIn and check out John Deere

Follow Tuple

Want to hear more? Check out distributed.fm

Connect with Jack Hannah

Anthony Eden started DNSimple as a remote first, mostly asynchronous company in 2010 before it was cool.

In this episode of the Distributed podcast, host Jack Hannah sits down with Anthony, Founder and CEO, to discuss the intricacies of remote-first companies. Anthony shares his journey of building DNSimple as a remote-first company, highlighting how asynchronous communication and flexible structures foster a thriving tech culture. The discussion touches on what shapes a successful organization and the challenges he’s faced over the years.

Anthony also shares his experience with Shape Up and how it’s improved his team’s productivity and trust in each other.

Highlights:

• Remote work norms and fostering collaboration across different time zones 
• Anthony’s journey with Shape Up
• How to facilitate trust among team members
• DNSimple’s culture of collaboration

In this episode, we cover:

(00:00) - Kicking things off with Anthony Eden

(00:55) - Founding DNSimple: Anthony’s journey to remote work

(02:47) - Embracing remote work: the time zone challenge

(04:02) - Company growth and team structure at DNSimple

(06:56) - The shift to Shape Up: solving development challenges

(10:42) - Facilitating trust and commitments in remote teams

(16:06) - Asynchronous collaboration tools

(21:45) - Aligning remote work practices: learning from experiments

(31:20) - The human side of remote work: building emotional connections

(35:43) - Conclusion: looking ahead with a growth mindset in remote work

References mentioned:

DNSimple’s time tracking experiment

Shape Up

Where to connect further:

Connect with Anthony Eden on LinkedIn

Follow Tuple

Want to hear more? Check out distributed.fm

Connect with Jack Hannah

Trust, collaboration, and adaptability define the best engineering teams.

In this episode of the Distributed podcast, host Jack Hannah sits down with Pavel Hubich, Software Engineer at Spotify, to explore the realities of remote and hybrid work. Pavel shares his journey navigating career shifts, relocations, and the challenges of distributed collaboration. He opens up about why he prefers working in person, how hybrid work can create communication bubbles, and what teams can do to foster trust despite physical distance.

They also discuss the impact of structured rituals like daily standups and the Swedish tradition of Fika, how mob programming transformed his team’s efficiency, and why balancing autonomy with connection is critical for engineers working remotely.

Highlights:

• Navigating career transitions from frontend to backend engineering while relocating across continents
• Why hybrid work can unintentionally create communication bubbles—and how teams can bridge the gaps
• The role of standups, casual rituals, and structured collaboration in building trust remotely
• Using mob programming and Architecture Golf to reduce context switching and improve team alignment
• Finding a balance between focus, flexibility, and human connection in a remote-first world

In this episode, we cover:

(00:00) – Kicking things off with Pavel Hubich

(01:24) – From EPAM to Spotify: Pavel’s software journey

(05:18) – Relocating to San Francisco for on-site work

(08:01) – Why Pavel prefers the office over remote

(13:56) – Rituals and loading screens: creating mental transitions

(16:03) – The real challenge of remote work: earning trust

(18:24) – Standups and Fika: building connection remotely

(21:45) – When high output doesn’t equal team cohesion

(26:29) – How mob programming brought the team back together

(29:53) – Using architecture golf to share context and collaborate

(34:29) – Making hybrid work without creating bubbles

(36:25) – Building trust without burning out

Where to connect further:

Connect with Pavel Hubich on LinkedIn

Follow Tuple

Want to hear more? Check out distributed.fm

Connect with Jack Hannah

How do you foster connection and collaboration in a remote-first world?

In this episode of the Distributed podcast, host Jack Hannah sits down with Nick Cash, Senior Vice President & Head of Technology at Jam City, to explore the unique challenges and opportunities of leading a hybrid team across the globe. Nick shares insights into Jam City’s hub-and-spoke organizational structure, the importance of reducing friction in communication, and the value of synchronous collaboration. He also discusses strategies for empowering engineers, fostering connections across teams, and building a culture of trust and innovation in a remote-first environment.

Highlights:

• Jam City’s hybrid approach to remote-first work and global team dynamics
• Reducing friction with clear processes and effective communication tools
• The importance of synchronous collaboration for solving complex problems
• Building connections through programs like Jam City University
• How fostering team relationships leads to better project outcomes

In this episode, we cover:

(00:00) – Kicking Things Off With Nick Cash

(04:44) – Optimizing Product Lifecycle and Team Agility

(08:35) – Integrating Processes with Flexibility

(12:34) – Fostering Occasional Team Interactions

(14:40) – Balancing Mentorship and Independence

(19:06) – Effective Team Communication Boosts Productivity

(22:44) – Fostering Success at Jam City

(25:44) – Leveraging Curiosity for Networking Success

(27:17) – Jam City's Global Talent Strategy

(32:23) – Exploring Meetings vs. Problem-Solving Calls

(34:37) – Comparing In-Person and Virtual Collaboration Perceptions

Where to connect further:

Connect with Nick Cash on LinkedIn

More about Jam City

Follow Tuple

Want to hear more? Check out distributed.fm

Connect with Jack Hannah

What happens when a fully remote team prioritizes speed, flexibility, and customer feedback?

In this episode of the Distributed podcast, Host Jack Hannah talks to Sumeet Jain, Head of Engineering at Sublime Security, about how they manage one-week development cycles to stay agile and responsive to their customers’ needs. Sumeet shares how the team’s reliance on Slack and Notion streamlines workflows and minimizes friction, helping engineers stay connected even across time zones.

They also discuss how making work visible, listening to customers, and maintaining a balance between speed and quality are key to Sublime’s success in a fast-paced remote environment.

Highlights:

• Why a one-week development cycle gives Sublime a competitive edge
• How the team uses Slack and Notion to manage tasks and streamline communication
• The importance of making work visible to foster camaraderie in a remote team
• How prioritizing customer feedback drives development decisions
• Maintaining speed and focus while ensuring quality in a rapid delivery environment

In this episode, we cover:

(00:00) – Kicking things off with Sumeet Jain

(01:13) – Catching the software bug with a Penny Hardaway fan site

(02:21) –  Running a fully remote team across North America

(03:20) – Why Sublime chose one-week engineering cycles

(07:00) – Inside the Monday planning ritual and company alignment

(11:39) – How customer feedback drives weekly priorities

(14:08) – Rethinking under promise and over deliver culture

(19:02) – Principles behind Sublime’s lightweight operations

(22:59) – Using emoji reactions to create tasks in Slack

(28:47) – Organizing work through “T channels”

(34:01) –  Sumeet’s favorite remote work gear and why air quality matters

Products mentioned:

UGMONK Analog Wood Card Holder

Aranet4 CO2 Monitor

Where to connect further:

Connect with Sumeet Jain on LinkedIn

Follow Tuple

Want to hear more? Check out distributed.fm

Connect with Jack Hannah

How do you transition from a solo founder to leading a thriving remote team?

In this episode of the Distributed podcast, Host Jack Hannah sits down with Chris Oliver, Founder of GoRails and Host of the Remote Ruby podcast, to discuss his journey from working solo to building a successful three-person remote team. Chris shares a candid look at how he overcame the challenge of scaling a business, the importance of asynchronous communication, and how he created a system that fosters remote collaboration. 

Highlights:

• Strategies for transitioning from solo work to team leadership
• Balancing asynchronous and synchronous collaboration for remote teams
• How Chris built a sustainable business that works for him, not the other way around
• The tools and processes that enable GoRails to thrive remotely

In this episode, we cover:

(00:00) – Kicking things off with Chris Oliver

(00:42) – The origin of GoRails: From tutorials to product market fit

(04:03) – Challenges of solopreneurship and the decision to expand

(06:28) – Adapting processes for a team environment

(09:27) – The value of pair programming in remote work

(12:46) – Balancing asynchronous and synchronous communication

(18:35) – Creating a calm company culture at GoRails

(37:16) – Encouraging entrepreneurship and lessons from experience

Referenced:

• Railscasts by Ryan Bates
• Michael Gerber’s Book: The E-Myth on Amazon

Where to connect further:

• Connect with Chris Oliver on X and GitHub
• More about GoRails
• Follow Tuple
• Want to hear more? Check out distributed.fm
• Connect with Jack Hannah