Most important take away

Most companies over-plan by 100x and slow themselves down with “time horizon friction” — meetings about future work crowd out the actual building. Jean-Michel Lemieux (ex-CTO Shopify, ex-VP Eng Atlassian) argues that shipping reduces risk more than planning does, and that real progress comes from a small group of high-trust people making aligned decisions and writing code, not from process layers like scrum, story points, and TDD ceremonies.

Summary

Actionable insights and career advice:

• Do what you’re good at, not just what you love. Lemieux’s guidance counselor pushed him into CS because he was good at it; love followed competence. Career advice for grads: the safe path is rarely as safe as it looks, and the risky path is rarely as risky.
• Build movements, not products. Both Shopify (entrepreneurship, Tim Ferriss) and Atlassian (open source, easy software, “cash for clunkers”) deliberately built communities around a cause. Your job as a founder is to get a group of people who care about what you care about as much as you do.
• Pick what to polish and what to rush — every month. Don’t choose speed vs. quality as a single bucket. Each month, decide which half of work must be best-in-class (security, payments, the headline feature) and which half can be timecapped and shipped rough.
• Measure progress by shipped code, not meetings. “Code talks, bullshit walks.” Look at PRs and the hum of weekly output. Same measure he used at Shopify.
• Kill time-horizon friction. Over-planning bottlenecks builders because non-builders need builders to plan. Replace it with: a quarterly “where are we going” conversation, a monthly “what are we doing next” linear review, and one weekly 1-hour “who’s stuck” meeting. That’s it.
• “Hire great people and get out of the way” is the worst advice. Alignment is messy and requires constant pairing. Onboard new VPs by pair-programming on leadership: assign three concrete things to ship in six months and ask them to find three more. Iterate together (e.g., reviewing blog posts five or six times) to build shared quality bars.
• Micro-align constantly. Send your boss a Slack every day with a decision you made or a thing you saw. Use Susan Scott’s decision tree — roots (don’t surprise me), trunks (brainstorm with me), leaves (don’t bug me).
• Hiring playbook (three steps):
  1. Snowboard test: Ask “what’s your dream job here?” and let them talk for 10 minutes to reveal natural instincts.
  2. Depth check: Have them teach you about the thing they love — look for multi-layered problem-solving.
  3. Hardest thing built: Calibrates their internal quality bar and stretch capacity.
• Avoid rushed hiring. When someone leaves, take the monkey off your back — tell the team “you’re all adults, what are we shipping?” Always be networking: talk to one person a week you’d love to work with, every week, forever.
• Tech patterns and AI: Lemieux is bullish. AI co-pilots write ~80% of his code, freeing him for architecture. He compares it to firing his high-school band in 1988 to do a musical solo via MIDI. Expect smaller, less bloated teams — and programmers redistributed away from social/ad-tech toward under-invested areas (healthcare, agriculture, education, renewable energy, even a “country operating system”).
• Foundation-model layer has two exits: acquisition by a platform incumbent or 20-year scale. Platform/infrastructure bets are de-risked by acquirer demand.
• Pace bunny for teams. Just like marathons, leaders need external benchmarks. Talk to other CTOs regularly to build an internal model of what great looks like.
• Sales–product tension > sales reporting in. At Shopify, Lemieux ran sales for a year. The fix: bring the right customers at the right time. Shopify’s strategy mapped retailers by complexity vs. volume — mom-and-pop and Kardashian both have low complexity, so they share 80% of platform needs. Focus sales on high-volume-low-complexity (e.g., Supreme) to buy roadmap time before chasing complex accounts.
• Career advice — start on support. Lemieux’s best move at Shopify was spending his first month on customer phones. If you can’t take support calls for the product you lead, you should be fired.
• Buy yourself time. From a hostage-negotiation book: when pressured to hire fast, throw the constraint back. Stop negotiating against yourself.

Chapter Summaries

• Origin story (high school MIDI to CTO): Lemieux fell in love with computers as a creative tool, replacing his high-school band with a keyboard and computer for a Les Misérables medley. Career advice: do what you’re good at.
• Shopify vs. Atlassian — Venn overlap: Both played the long game and built movements (entrepreneurship at Shopify, open-source/easy-software at Atlassian) with paired founder duos.
• Where they differ: Shopify shipped on quality and did fewer things (Toby would stop projects on quality); Atlassian shipped on speed, did more M&A, and was sharper at monetization. Shopify could be 10x revenue with more pricing levers.
• Speed vs. quality for founders: Don’t pick one bucket — every month decide what gets polished and what gets timecapped.
• Measuring progress: Look at shipped code. Watch the weekly hum.
• Retiring from software process: No scrum, story points, TDD ceremonies. “Time horizon friction” caused by over-planning slows teams 100x. Replace with quarterly direction + monthly linear review + weekly “who’s stuck.”
• Why “hire great and get out of the way” is wrong: Alignment requires pairing. Onboard VPs by co-shipping three things in six months. Use micro-alignments (daily Slack to boss) and Susan Scott’s root/trunk/leaf decision framework.
• Hiring three-step process: Snowboard test (instincts), depth (teach me), hardest thing built (quality bar). Don’t rush. Always be networking.
• AI and the future of code: AI writes 80% of code; lets him focus on architecture. Programmers will redistribute to under-served sectors. Teams get smaller, less bloated.
• Incumbents and platform bets: Foundation models have two exits — acquisition or 20-year scale. Hard tech is a different game than software investing.
• Why great teams go average: No pace bunny. Leaders should benchmark externally with other CTOs.
• Zero-to-one transition: Lonely. Wife as cheerleader. Using new products (e.g., Equals) is a great way to meet people and learn.
• Quickfire: CEOs underestimate go-to-market grind. Founders hire too quickly — wait until things break. Start on support phones. Tension is most acute among design/product/engineering (sales gets ignored). At Shopify, running sales for a year aligned the team on customer segmentation by complexity vs. volume.