1. OpenAI Jalapeño: Better Than Nvidia Blackwell — SemiAnalysis

  • Why read: Details OpenAI's new AI inference chip, Jalapeño, and what it means for hardware economics.
  • Summary: OpenAI built a general-purpose inference chip, Jalapeño, in 16 months. It beats top Nvidia and AMD chips in tokens per watt. It avoids prefill-decode disaggregation and uses HBM4 memory to improve performance and cut datacenter power use. If this scales, inference costs and power limits could drop, making frontier models much cheaper to run.
  • Read more

2. Why Ramp built its own in-house coding agent, Inspect — pragmaticengineer.com

  • Why read: Explains why Ramp passed on off-the-shelf AI coding tools to build an internal agent that now writes 75% of their merged pull requests.
  • Summary: Ramp hit the limits of standard AI coding tools, which lacked deep access to internal systems and ran into local machine constraints. In response, they built Inspect. It runs in remote sandboxes with full access to their APIs, databases, and telemetry. Inspect can run backend tests and visually verify frontend changes on its own. Ramp has since built over 200 internal agents on this platform. It shows the value of wiring AI directly into proprietary infrastructure rather than relying on generic tools.
  • Read more

3. The AI-Native SDLC playbook — claude.com

  • Why read: A guide to updating your software development lifecycle so human reviews don't bottleneck AI coding speed.
  • Summary: AI writes code fast, pushing bottlenecks to planning, review, and deployment. An AI-native SDLC turns the traditional linear process into a loop. Each stage produces a machine-readable artifact that triggers the next step. Humans stop writing boilerplate and start acting as approval gates. This setup helps security and governance keep up with agent output.
  • Read more

4. Routing is coming for the frontier AI labs — Axios

  • Why read: Looks at how AI model routing treats frontier models like commodities and changes how companies spend on AI.
  • Summary: Companies are using AI routers like OpenRouter to match queries with the cheapest model that gets the job done. They route simple tasks to open-weight models and save frontier models for hard problems. This cuts costs and limits vendor lock-in. As models become interchangeable, frontier AI labs will likely see their margins shrink and their direct-to-customer businesses suffer.
  • Read more

5. The two AI gateway patterns in production inference — X (formerly Twitter)

  • Why read: Breaks down the difference between AI gateways built to consume third-party APIs and those built to serve your own models.
  • Summary: Teams scaling AI need to manage routing, limits, and authentication. An "access gateway" helps consume external model APIs, focusing on flexibility and fallback routing. A "serving gateway" sits between your own models and your customers, handling billing, tenant isolation, and quotas. You have to know which one you're building. Using the wrong architecture will mess up your cost tracking or customer billing.
  • Read more

6. Routing Intelligence: Prateek Jain on Long-Horizon Agents — X (formerly Twitter)

  • Why read: Google DeepMind’s Prateek Jain explains the architecture needed for AI agents to run month-long tasks.
  • Summary: Long-running agents struggle with context limits, costs, and memory loss when handing work to sub-agents. Expanding context windows drives up inference costs too fast. To fix this, researchers are building elastic models and passing full cache states to sub-agents instead of text summaries. Builders should expect a shift toward agents that manage their own compute budgets and focus on ongoing planning rather than single tasks.
  • Read more

7. SaaS Isn’t Dead. Sameness Is. — leaflet.pub

  • Why read: Argues AI will end one-size-fits-all software but increase the value of the infrastructure underneath it.
  • Summary: SaaS used to force companies into generalized workflows because custom software cost too much. AI changes this by generating custom apps for pennies. But the backend value of SaaS—securing data, moving money, and handling compliance—remains. Software vendors will shift to monetizing this data infrastructure rather than selling seats for standardized interfaces.
  • Read more

8. The end of programming — pauldix.com

  • Why read: A firsthand look at how AI agents and large context windows are replacing manual coding.
  • Summary: Bun recently rewrote its runtime from Zig to Rust, generating over a million lines of code in days using frontier models. Engineers are shifting from typing code to acting as supervisors who define architecture and check AI outputs. As these models get cheaper, AI-generated software will dwarf human-written code. Engineering teams need to focus on automated QA, verification, and deployment to adapt.
  • Read more

9. Moats in the age of floods — X (formerly Twitter)

  • Why read: How application-layer companies can build moats even as raw AI becomes a cheap commodity.
  • Summary: Raw AI is becoming a cheap utility, eroding traditional technical moats. But models alone can't navigate messy human incentives and legacy systems. Companies can build defenses by managing agent teams, organizing multiplayer networks, and capturing proprietary workflow data. Successful AI apps will stop charging per seat and start charging for outcomes, like closed tickets or new revenue.
  • Read more

10. How we Build Agent Environments & Tasks — X (formerly Twitter)

  • Why read: LangChain's guide to building synthetic environments and benchmarks for AI agents.
  • Summary: Improving agents requires testing them against realistic environments and solid rubrics. The best way to build these benchmarks is in two steps: define a "world spec" of domain knowledge, then use AI to generate specific task specs from it. This separates deciding what a task should be from the grunt work of coding the environment. Teams need this kind of pipeline to track performance and catch regressions.
  • Read more

11. the ai-natives are not alright; or i've become an uncle — X (formerly Twitter)

  • Why read: A look at the sloppy context habits slowing down AI-native developers.
  • Summary: Developers are bloating agent contexts by running single sessions across thousands of messages. Instead of breaking problems into parts, they dump half-formed thoughts into massive prompts. This forces them to use expensive frontier models just to cut through the noise. With clean context, cheaper models could do the job. Teams need to enforce better prompt hygiene and break tasks down to scale efficiently.
  • Read more

12. You need to find product-market fit again (sorry) — X (formerly Twitter)

  • Why read: PostHog's playbook on disrupting your own product before an AI competitor beats you to it.
  • Summary: AI agents mean even companies with product-market fit have to start over. To survive, fund internal "attacker" teams and treat them like seed bets. Give these teams your uncopyable assets—like distribution or proprietary data—so they have an advantage. Launch early, dogfood the product, and let real user behavior drive decisions.
  • Read more

13. LLMs could control their host machines by exploiting inference engines — Boyd's Blog

  • Why read: A security warning on how LLM outputs can trigger malicious code execution on GPU host machines.
  • Summary: Inference engines like vLLM parse complex chat formats and multimodal outputs. This creates vulnerabilities: an LLM can generate tokens that exploit parser bugs to run arbitrary code on the host machine. Because these machines access data centers and model weights, they are high-value targets. To limit risk, separate GPU token generation from CPU token parsing and treat all model outputs as untrusted data.
  • Read more

14. Inventing a new software primitive: the “Execution Map” — Substack

  • Why read: Proposes the "Execution Map," a software primitive for managing the hidden meta-work in B2B workflows.
  • Summary: Standard workflow software maps the ideal path but ignores the reality of follow-ups and missing docs. An Execution Map visualizes the actual tasks needed to get a job done. Using LLMs, these maps generate dynamically to track progress and prompt follow-ups. This pushes B2B software past abstract process modeling and into execution management.
  • Read more

15. Burning the $1B Ship — X (formerly Twitter)

  • Why read: A breakdown of Electric’s pivot from a legacy IT service to an AI-native platform.
  • Summary: Electric hit $50M ARR combining managed IT services and software, but the model lacked true software margins. To adapt to AI, they laid off 60% of their staff, sold their main services division, and rebuilt as an AI platform. This let them embed IT automation into HR and payroll systems for zero-touch hardware management. It shows that moving to AI sometimes means tearing down a working business model.
  • Read more

Themes from yesterday

  • AI Routing & Hardware: Model routing is pulling power away from frontier labs by focusing on cost. Meanwhile, custom chips like OpenAI's Jalapeño are cutting the costs of running models at scale.
  • Coding to Supervision: Engineers are moving away from typing code to reviewing AI outputs and managing agent-driven development lifecycles.
  • Self-Disruption: Established companies are realizing they have to tear down their own working products and rebuild them for AI to survive.
  • Context Hygiene & Security: Long-running agents require strict context management to avoid bloating. At the same time, securing inference engines against parser exploits is becoming mandatory.