Event-driven architectures promise flexibility at scale, but as Ian Cooper's work at Just Eat Takeaway makes clear, they demand a rigor that many teams overlook. His "ABCs" of messaging, Address, Binding, Contract, are not academic abstractions; they are the practical scaffolding that separates a manageable async system from a tangled web of undebuggable events. This is the kind of grounded engineering thinking that deserves more attention, especially as the industry races toward AI-driven workflows that depend on reliable data pipelines. Cooper's focus on discovery, governance, and automated provisioning with tools like AsyncAPI and CloudEvents offers a blueprint that any team building event-driven systems should study closely.
The parallels to our own coverage are striking. In Treat Context Like Code to Scale AI Agents With Control, Patrick Debois argues that managing context for AI agents requires the same discipline we apply to software artifacts, versioning, distribution, and observability. Cooper's message is the same, applied to the messaging layer: treat your event contracts, schemas, and addresses as code, not as afterthoughts. Without that discipline, an event-driven system becomes a black box. Similarly, Let Coding Agents Handle the Work So You Can Focus on Insight explores how automation frees teams for higher-level discovery, but only when the underlying infrastructure is trustworthy. Cooper's automated CI/CD pipelines for provisioning async APIs are exactly the kind of foundation that makes that trust possible.
What sets Cooper's approach apart is its modesty. He does not claim to have solved distributed computing. Instead, he shares how Just Eat Takeaway uses schema registries and automated governance to prevent the kind of silent failures that plague event-driven systems. This is not glamorous work, but it is essential. For any team currently wrestling with async APIs, the clear takeaway is this: invest in your contract definitions and provisioning pipelines before you invest in fancy event-processing logic. Without a solid Address, Binding, and Contract, your events will eventually become noise.
The open question Cooper leaves us with is whether the broader ecosystem will standardize fast enough to make these practices portable across teams and tools. AsyncAPI is a strong candidate, but adoption is uneven. As more organizations move toward event-driven architectures, and as AI agents increasingly depend on real-time event streams, the cost of ignoring these fundamentals will only grow. The teams that get the ABCs right today will be the ones that can actually scale tomorrow.