1. The AI Decoupling — Pierre-Carl Langlais

  • Why read: Tracks the growing divide between traditional SaaS and AI-native companies rooted in model economics.
  • Summary: The tech sector is splitting into software and AI. Sparse mixture-of-experts (MoE) architectures now enable cheap, long-context inference, allowing models to route tasks dynamically and absorb the application layer entirely. This creates two distinct markets with different valuation multiples, hiring needs, and growth trajectories. For product teams, this means unit economics and inference speed matter more than raw benchmark scores.
  • Read more

2. The Org Chasm — anhtho 🍊

  • Why read: Argues that the bottleneck for AI adoption is no longer technical; it’s organizational.
  • Summary: Intelligence is now basic infrastructure. The real hurdle isn't budget or integration; it's how companies work. Right now, employees use AI individually while workflows stay the same. Real value requires redesigning roles around agents and creating positions like AI Operations Specialists. Stop trying to prove model capabilities. Instead, focus on mapping processes, setting strict action boundaries, and handling liability inside your system of record.
  • Read more

3. The AI buildout has a physics problem. — Lovable

  • Why read: Maps the physical supply chain limits that will throttle AI scaling.
  • Summary: Everyone watches Nvidia, but the real bottlenecks for AI expansion are deeper in the physical supply chain. The limits involve obscure components like indium phosphide wafers, hybrid bonders, EUV scanners, and massive power constraints requiring gas turbines and gigawatts of electricity. Hyperscaler spending is capped by these physical realities, which are managed by a few obscure companies. Tracking these upstream chokepoints shows exactly where the AI buildout will stall next.
  • Read more

4. The Design System Advantage Is Memory — Romina Kavcic

  • Why read: Explains why tool-wielding agents fail without access to a team's historical context.
  • Summary: Giving AI access to your design system isn't enough. Agents fail because they lack the institutional memory of why certain patterns were chosen or discarded. If critical context lives in Slack, ADRs, and Figma comments, agents will make wrong assumptions and repeat old mistakes, forcing humans to babysit them. The real moat isn't the model you use; it's how well your company codifies its decision history into structured, usable data.
  • Read more

5. Agree it's interesting, but I don't think it's correct — ᴅᴀɴɪᴇʟ ᴍɪᴇssʟᴇʀ 🛡️

  • Why read: Argues future companies will function as algorithm graphs driven by strict standard operating procedures.
  • Summary: Soon, automated SOPs will execute the bulk of company work. Manual intervention will be treated as a bug or an edge case to be systematized. Companies will look like graphs of algorithms, pushing humans out of execution and into problem framing and vision. If you want to prepare for multi-agent execution, your priority today is aggressively documenting and standardizing your current workflows.
  • Read more

6. Using AI to write better code more slowly — Nolan Lawson in

  • Why read: Pushes back on "vibe coding," suggesting we use LLMs to find bugs slowly rather than write code fast.
  • Summary: Fast AI code generation often creates low-quality output. Instead, developers should use multi-agent workflows running several models at once to deliberately hunt for subtle bugs, logic flaws, and architectural weak points. This method yields a near-zero false positive rate. It shifts the job from typing boilerplate to triaging fixes and attacking technical debt, leading to healthier codebases and a better understanding of how systems fail.
  • Read more

7. How I Use Cursor — lauren

  • Why read: Explains why purpose-built AI GUIs like Cursor beat terminal-based agent orchestrators.
  • Summary: Integrated IDEs are outperforming raw CLI tools for AI coding. Native UI features like rapid context management, multi-model reviews, and instant subagent spawning lower the cognitive overhead of managing context windows. Engineers often try to build custom CLI orchestrators, but what they really need are better UI abstractions that handle agent amnesia automatically. If we treat AI agents like new hires, they need tools that integrate local codebase context without requiring endless prompt engineering.
  • Read more

8. Brand Engineering — Joumana

  • Why read: Argues that in deep tech, making your brand legible is a core founder responsibility.
  • Summary: Treating branding as a cosmetic afterthought is a mistake. Capital, talent, and distribution decisions are now made based on your company's external surface area. If your tech is hard to explain, the market assumes it isn't real, which creates friction in rooms you aren't in. The founder has to own this translation. You have to turn complex architecture into a clear narrative to ensure your work makes sense to investors, recruits, and the algorithms parsing your company.
  • Read more

9. A Tool That Audits All of Your Customer Data — Jordan Crawford

  • Why read: Explains why clean data pipelines must precede any AI-driven customer insights.
  • Summary: AI reporting falls apart if the underlying CRM, billing, and product data is messy. Bad primary key joins, duplicated entities, and overlapping columns wreck the accuracy of downstream agents. You need an automated auditing layer to check data integrity before ingestion. Fixing your upstream data taxonomy isn't optional; it's a hard prerequisite for deploying automated intelligence.
  • Read more

10. Book Review: Focus, The ASML Way — Henrique Cruz

  • Why read: Reviews the operational history of ASML, the hardware monopoly underpinning the AI boom.
  • Summary: ASML's extreme ultraviolet (EUV) lithography machines are the bottleneck for the entire semiconductor industry. The company won through decades-long partnerships (like their alliance with Zeiss for optics) and a willingness to play the long game against incumbents. They navigated patent wars using aggressive business tactics, combining a deep technical moat with legal pressure. Understanding how ASML operates clarifies the physical and geopolitical realities of the AI supply chain.
  • Read more

11. Beyond the Hype. — rutgers.edu

  • Why read: Offers a framework for tracking AI progress by focusing on physical constraints and measurable economic impacts.
  • Summary: To understand where AI is going, ignore the noise and watch the physical realities: the material footprint of infrastructure and the shifting mechanics of reinforcement learning. Early data shows that broad labor displacement is slow, but entry-level knowledge work is already facing severe compression. Better decisions come from anchoring your views in data center power limits and actual job metrics, not speculative sci-fi risks.
  • Read more

12. Remarks on Magnifica Humanitas — Chris Olah

  • Why read: An AI lab founder argues why frontier labs need external accountability.
  • Summary: AI labs face commercial and geopolitical pressures that conflict with safety. Because models are "grown" on human data rather than explicitly coded, their behavior is unpredictable. This opacity means oversight can't just come from the engineers building them; it has to come from civil society, the humanities, and external critics. Getting outside perspective is necessary to manage the global impact of these systems.
  • Read more

13. AI is Not Normal Technology — O.H. Scharfman

  • Why read: Argues against treating AI as just another software tool, highlighting its unique pace and autonomy.
  • Summary: Calling AI "normal technology" ignores its speed and capacity for autonomous action. Past general-purpose technologies like electricity rolled out slowly and predictably. AI is different. Treating it as a simple, controllable tool leads to weak governance and sloppy alignment efforts. We have to recognize it as a fundamentally new class of technology to build the right policies and safety measures.
  • Read more

14. A few notes on Pope Leo XIV’s encyclical on AI — Simon Willison

  • Why read: Examines the Vatican's new framework on AI, focusing on model interpretability and global resource allocation.
  • Summary: The papal encyclical "Magnifica Humanitas" offers a sharp technical critique of AI, specifically targeting the interpretability problem. It notes that LLMs are cultivated rather than built, leaving their internal logic opaque even to the people who train them. The document argues AI fails basic ethical tests if it extracts resources from subordinate regions to increase consumption for a few. It’s a strong push for the tech industry to treat operational transparency and global equity as baseline requirements.
  • Read more

15. not a loser — kache

  • Why read: A reminder of the intensity and depth required to achieve true technical mastery.
  • Summary: Outlier success requires rejecting the median. Real engineering breakthroughs come from people who ignore standard constraints and dig into the absolute bottom of a stack, from the database engine down to how NAND chips are fabricated. The drive to understand the underlying physical reality of technology separates tool users from system builders. For founders and operators, protecting and feeding this kind of obsessive curiosity is a massive advantage.
  • Read more

Themes from yesterday

  • From Implementation to Org Design: The main barrier for AI adoption is no longer technical capability. It’s how companies redesign workflows, structure institutional memory, and formalize SOPs to delegate work to agents.
  • Physical Constraints: Attention is moving upstream from software capabilities to the hard physical limits of AI infrastructure, specifically power generation, hardware components, and data center capacity.
  • Interpretability and Oversight: Because models are grown rather than engineered, their unpredictability requires external oversight. There is a push to prioritize transparency and human impact over raw capability.
  • Quality over Vibe Coding: AI engineering is moving past fast code generation. The focus is shifting to UI-native, multi-agent workflows used deliberately to find bugs, review code, and tackle technical debt.