#38 | Sunday reads for EMs

My favourite reads of the week to make your Sunday a little more inspiring.

Mar 08, 2026

Paid subscribers get 50 Notion Templates, The EM’s Field Guide, and access to the complete archive. Subscribe now.

Six Rules for Designing Company Goals (Molly Graham)

tl;dr: Goals exist purely to create clarity, not to represent every department’s priorities. No more than three company goals, one clear winner when metrics conflict, explicit non-goals, and a single accountable owner per goal.

Nobody Gets Promoted for Simplicity (Matheus Lima)

tl;dr: Organizations often reward visible complexity instead of good judgment, because complex systems create better narratives in interviews and promotion packets. Engineers must learn to document the decisions behind simplicity, and leaders must explicitly reward the complexity that teams avoided, not just the systems they built.

How We Hire Engineers When AI Writes Our Code (Dan Federman)

tl;dr: In a world where AI can generate most of the implementation, this hiring approach shifts interviews from coding ability to engineering judgment. Candidates are given a real product spec and encouraged to use AI, but the evaluation focuses on trade-offs, architecture, questioning the spec, and knowing when code is not ready. Implementation is getting commoditized, but judgment, taste, and ownership are becoming the real differentiators.

Strategic choices: When both options are good (Jason Cohen)

tl;dr: The core idea here is that real strategy isn’t choosing between good and bad options - it’s choosing between two good ones and accepting the downsides that come with your choice. This mental model helps teams define explicit trade-offs. If your strategy doesn’t force painful trade-offs and say no to attractive alternatives, it’s probably not a strategy at all.

Reflections on the Future of Software Engineering Retreat (Rachel Laycock)

tl;dr: A few interesting signals about where engineering might go. One standout idea: AI tools are increasing cognitive load rather than reducing it - developers are generating more code but also facing more decision fatigue. The other notable shift is toward engineers acting as orchestrators of agents and governance systems rather than pure implementers.

Engineering Productivity in 2026: Where AI Actually Pays Off (Anna Shipman)

tl;dr: AI amplifies the quality of your engineering systems rather than fixing them. In a well-structured codebase it dramatically speeds up delivery; in a messy one it accelerates chaos. The practical implication: architecture, documentation, and systems thinking matter even more than before.