​(view in browser)​

Dear Reader,

Welcome to the 290th edition of the Data Science Briefing!

This week’s bundle presents a clear theme: scale alone isn’t enough to save us. Cal Newport’s New Yorker essay argues the GPT-5 moment looks more like narrow, post-training polish than a leap, raising the real possibility that headline LLM progress is slowing. Apple’s “Illusion of Thinking” backs that up empirically: so-called reasoning models improve on mid-tier puzzles but collapse past modest complexity, suggesting brittle gains rather than general problem-solving. Also, longer inputs don’t just dilute answers; distractors and even the structure of the haystack can degrade accuracy as context grows.

Meanwhile, the JAX-ML “How to Think About GPUs” chapter reminds builders that real wins come from hardware pragmatics, not just FLOPs on a spec sheet. In that spirit of pragmatism, Wilson Lin’s post is a standout case study: a from-scratch web search engine using ~3 B embeddings, a 200-GPU pipeline, and sharded HNSW to hit sub-second latency. Finally, for those hoping agents will simply “ship the code,” Zed’s essay argues today’s LLMs can’t maintain the dual mental models (requirements vs. reality) that real software work demands. Progress is coming from systems thinking, tight hardware/software co-design, careful evaluation, and structured runtimes, and not blind scaling or wishful benchmarks.

This week’s research thread explores the connection between empirical humility and design pragmatism. Sekara et al. show that our “ground truth” isn’t so grounded: three flagship settlement maps disagree widely across 44 African countries, with geography and socio-economics driving mismatches—reminding us that downstream ML claims rest on shaky basemaps. On the social side, a Science report finds echo chambers and extreme voices can emerge even without recommendation algorithms, implying polarization dynamics are endogenous to the medium, not just its ranking functions. Hébert-Dufresne et al. formalize the mechanism: self-reinforcing cascades yield broad “critical-like” regimes and power-law spread without fine-tuned parameters, a better fit to how beliefs and products actually propagate.

“Speed Always Wins” surveys efficient LLM architectures framed around latency first, while another survey argues diffusion language models can cut inference delay via parallel, iterative denoising while using bidirectional context. At the stack level, PyTorch vs. TensorFlow trade-offs still matter by workload and deployment path, not ideology. And if you’re building agentic systems, NVIDIA’s position paper makes the economic and engineering case that small, specialized models will beat monoliths in practice.

This week's book is "Behavioral Network Science: Language, Mind, and Society" by T. T. Hills. You can find all the previous book recommendations on our website. In this week's video, we have a lecture by Yan LeCun on how we won't reach AGI by scaling up LLMs.

Data shows that the best way for a newsletter to grow is by word of mouth, so if you think one of your friends or colleagues would enjoy this newsletter, go ahead and forward this email to them. This will help us spread the word!

Semper discentes,

The D4S Team

Michael Lanham's book, "AI Agents in Action", is a practical guide for developers who want to build autonomous AI agents using large language models (LLMs) and open-source frameworks. The book focuses on real-world engineering rather than abstract theory, offering a step-by-step approach to building agent architectures, managing multi-agent systems, and using LLMs to solve business problems. It's written for developers and technical professionals who have the necessary foundational skills in Python and want to move from theoretical knowledge to hands-on development.

The book's strength lies in its gradual layering of complexity, starting with basic concepts and moving to advanced topics like multi-agent orchestration and prompt engineering. Lanham uses open-source tools like CrewAI, AutoGen, and Nexus, and includes annotated code examples to help readers follow along. This approach effectively bridges the gap between academic theory and practical development, making it a valuable toolkit for machine learning engineers who want to create production-ready solutions for tasks like workflow automation and customer service bots. The book also provides insightful commentary on integrating key components like memory and feedback loops into agent-based systems.

However, the book has some notable limitations. A major critique is its optimistic portrayal of the tools and techniques, often overlooking critical discussions about their limitations, trade-offs, and performance at scale. It focuses on illustrative projects rather than addressing issues of robustness and reliability, which are crucial for high-stakes, enterprise-grade deployments. Another drawback is the lack of extended use cases or full-scale system integration examples, which would provide a more complete understanding of an agent system's lifecycle, maintenance, and long-term performance in a real-world business environment.

1. ​What if A.I. Doesn’t Get Much Better Than This? [newyorker.com]
2. ​Context Rot: How Increasing Input Tokens Impacts LLM Performance [research.trychroma.com]
3. ​How to Think About GPUs [jax-ml.github.io]
4. ​The Illusion of Thinking: Understanding the Strengths and Limitations of Reasoning Models via the Lens of Problem Complexity [machinelearning.apple.com]
5. ​Building a web search engine from scratch in two months with 3 billion neural embeddings [blog.wilsonl.in]
6. ​Convo-Lang: LLM Programming Language and Runtime [learn.convo-lang.ai]
7. ​Why LLMs Can't Really Build Software [zed.dev]

• ​Uncovering large inconsistencies between machine learning derived gridded settlement datasets​ (V. Sekara, A. Martini, M. Garcia-Herranz, D.-H. Kim)
• ​Don’t blame the algorithm: Polarization may be inherent in social media (H. Richter)
• ​Self-Reinforcing Cascades: A Spreading Model for Beliefs or Products of Varying Intensity or Quality (L. Hébert-Dufresne, J. Lovato, G. Burgio, J. P. Gleeson, S. Redner, P.  L. Krapivsky)
• ​Speed Always Wins: A Survey on Efficient Architectures for Large Language Models (W. Sun, J. Hu, Y. Zhou, J. Du, D. Lan, K. Wang, T. Zhu, X. Qu, Y. Zhang, X. Mo, D. Liu, Y. Liang, W. Chen, G. Li, Y. Cheng)
• ​A Survey on Diffusion Language Models (T. Li, M. Chen, B. Guo, Z. Shen)
• ​A Comparative Survey of PyTorch vs TensorFlow for Deep Learning: Usability, Performance, and Deployment Trade-offs (Z. B. Alawi)
• ​Small Language Models are the Future of Agentic AI (P. Belcak, G. Heinrich, S. Diao, Y. Fu, X. Dong, S. Muralidharan, Y. C. Lin, P. Molchanov)

Yann LeCun: We Won't Reach AGI By Scaling Up LLMS

​

All the videos of the week are now available in our YouTube playlist.

​Unsubscribe​