What Happens to Conway’s Law When AI Joins the Dev Team?

TL;DR

In this episode of The Good Thing, Stefan and Jens explore Conway’s Law and what it reveals about scaling organizations. They compare monoliths and microservices, weigh the risks of résumé-driven development, and discuss how APIs and contracts keep AI agents reliable at scale.

Conway’s Law in Action

Stefan admitted Conway’s Law didn’t make sense to him at first. He compared it to recursion in computer science, something that feels impossible until a real problem makes it click. For him, that moment came from working with customers: monoliths worked fine for small teams, but as organizations grew, developers started stepping on each other’s toes.

The structure of your software will mirror the structure of the organization that built it.

He pointed to fast-growing companies shifting from monoliths to GraphQL Federation not because of tech limits, but because teams kept stepping on each other’s toes.

Monoliths, Microservices, and Mistakes

Jens cautioned that Conway’s Law isn’t a “problem,” it’s reality. The mistake comes when small teams prematurely adopt microservices.

If you are a single team, five devs, why do you need to split anything into another service? Just create a boring monolith, solve the problem, move forward.

He argued that complexity, not monoliths, is what brings companies down.

Résumé-Driven Development

The hosts warned against engineers chasing hype stacks for prestige. Stefan compared it to the early criticism of Dropbox and Windsurf : developers dismissed the tech, but missed the fact that real problems were solved.

Coding isn’t anything else but a tool that helps you solve a problem.

Jens added that résumé-driven choices often come from imposter syndrome and anxiety about keeping up.

AI, Anxiety, and Apprenticeship

Both hosts noted how AI tools like Cursor amplify the challenges of junior-heavy teams. Jens said apprenticeships in trades teach fundamentals by hand, while coding bootcamps often skip that grounding.

This is the biggest shift I’ve seen in my career.

They agreed AI can either empower developers or replace them, depending on whether teams use it to accelerate learning or as a crutch.

APIs as Safeguards

The episode closed with a discussion of APIs as the contract layer that keeps AI reliable. Jens gave the analogy of a waiter taking orders to the kitchen, with APIs acting as the safeguard.

At the core of everything we need APIs. We need strict contracts. Otherwise, banking wouldn’t work—nothing would work.

For Stefan, this showed why there is no AI without APIs: contracts make collaboration and safety possible at scale.