What I’m Reading This Week 📚

🧠 Llama 4 and the Goodhart’s Law Problem
https://www.lesswrong.com/posts/FHMcHmW4RKY5JiArJ/llama-does-not-look-good-4-anything

Meta’s Llama 4 release exemplifies Goodhart’s Law perfectly: when benchmarks become targets, they cease measuring what matters. Despite impressive metrics, many users echo Zvi Mowshowitz’s concerns about underwhelming real-world performance. This disconnect is why I rely on qualitative assessment – Claude’s tone simply works better for my needs, regardless of leaderboard positions. Our subjective experiences often reveal truths that synthetic benchmarks miss entirely.

🖼️ Breakthroughs in Multimodal Image Generation
https://www.oneusefulthing.org/p/no-elephants-breakthroughs-in-image

OpenAI’s integration of image generation within GPT-4o represents a fundamental architectural shift. By letting the language model control image creation directly, they’ve solved previously intractable problems (like the “room with no elephants” challenge). What I appreciate about Ethan Mollick’s analysis is how clearly he shows this isn’t just incremental improvement but a completely different approach that bridges text and visual understanding in revolutionary ways.

⚙️ Apple’s Darwin OS and XNU Kernel Architecture
https://tansanrao.com/blog/2025/04/xnu-kernel-and-darwin-evolution-and-architecture/

My time at Apple gave me unique appreciation for the XNU kernel – a hybrid architecture combining Mach microkernel with BSD Unix components that prioritizes real-world performance over theoretical purity. Watching this foundation scale from desktops to iPhones revealed its remarkable design foresight. Tansan Rao’s exploration illuminates these invisible architectural decisions that shaped products used by millions worldwide.

📊 Don’t Miss the Big Picture on Tariffs
https://x.com/raydalio/status/1909296189473693729?s=61

The market panic over tariffs misses deeper systemic shifts according to Ray Dalio: these policies aren’t causing our economic disruption but merely reveal underlying transformations. We’re witnessing the convergence of multiple historical cycles creating an unprecedented reset. In these times when established systems falter simultaneously, I find myself drawn to Morgan Housel’s wisdom about timeless patterns – focusing solely on market movements misses the epochal boundary we’re approaching.

What are you reading that’s helping you navigate these transformative times? 👇

#AIBenchmarking #MultimodalAI #TechArchitecture #MacroEconomics #GlobalTrends

What I’m reading this week 📚

Just shared some interesting finds:

YC GP Roundtables on the Future of Coding 🧠
https://youtu.be/IACHfKmZMr8?si=Um5bbcH_Be3CA7Sm
In the age of “code on tap,” the distinguishing factor for developers will increasingly be their “taste”—the nuanced judgment and experience that guide effective problem-solving and design (and at the other end, low level systems expertise to build those AIs).

TypeScript Native Port ⚡
https://devblogs.microsoft.com/typescript/typescript-native-port/
Yes please. In my experience, builds are an area where speedups always have devex ROI. It’s all about keeping developers in the flow.

Mental Models Overview 🧩
https://fs.blog/mental-models/
I’m a fan of mental models; they serve as frameworks that help our brains process complexity in daily life. Shane Parrish’s article on Farnam Street provides an insightful overview of the most powerful models. For instance, the reciprocity model highlights the benefits of positive actions prompting positive responses. Highly recommend this article and his excellent Farnam Street blog.

Visual Readability Patterns 👁️
https://seeinglogic.com/posts/visual-readability-patterns/
Found a good visual compilation of patterns to avoid for readable code. I found myself nodding along for several of these as Mark Griffin lays them out in great detail.

Garry Tan on Intelligence vs. Agency 🔥
https://x.com/garrytan/status/1894063324582625732?s=46
With intelligence now readily accessible, personal agency has become even more crucial. I couldn’t agree more; grit and self-volition are key markers of individuals who drive meaningful progress and innovation.

What articles have caught your attention this week? Share your recommendations below.

#TechInsights #ContinuousLearning

Simple, Complex, Right: The Engineering Complexity Paradox

I’ve been thinking about this pattern I’ve noticed over years of building software. It’s fascinating how engineers naturally gravitate toward three distinct approaches when solving problems.

The Minimalist Approach

These are your “if it works, ship it” folks. Love how they keep things dead simple - one function, minimal dependencies, quick deploys. Sure, some might call it too basic, but I’ve seen these solutions outlast many overengineered alternatives. They just work.

The Maximalist Zone

This is where most of us land at some point (guilty as charged). You know the type - implementing every design pattern they’ve just learned, breaking a simple app into 15 microservices, adding Redis to cache a static page. Classic architecture astronaut stuff. We’ve all been there, turning a simple form submission into an event-sourced distributed system.

The Pragmatic Sweet Spot

This is where it gets interesting. After years of swinging between too simple and too complex, you start developing this sixth sense. You pick the right tool because you’ve used the wrong ones. You know when to grab something off the shelf versus building custom. It’s not about showing off your technical chops - it’s about delivering value.

This mirrors most developers’ natural journeys. We start simple because we don’t know any better. Then we learn all these patterns and frameworks and go nuts applying them everywhere. Finally, if we’re lucky, we figure out when complexity is actually worth it.
Here a few things I’ve learned along the way:

• Simple doesn’t mean simplistic - choosing simplicity is different from being limited by it
• Make complexity prove its worth - every abstraction should fight for its place in your system
• The best engineers aren’t the ones who know the most patterns, but the ones who know when to use them and (perhaps) more importantly when NOT to use them

Next time you’re designing something, try this mental check: Does this really need to be complex? Am I solving the actual problem or just showing off? Will this scale with real needs (not imagined ones)?
The goal isn’t to impress at tech talks. It’s to solve real problems in ways that won’t make future-you curse past-you.
Would love to hear your experiences with this. Where do you find yourself on this curve?
Drop your thoughts below.

What I’m reading this week

LinkedIn Post

📚 This week in tech and markets:

1. Understanding reasoning LLMs
   Fascinating deep dive using DeepSeek R1 to explore how LLMs handle complex reasoning tasks. Key insight: optimizing for step-by-step reasoning comes with trade-offs we need to understand.

2. GitHub Copilot: The Agent Awakens
   GitHub’s raising the AI game: Agent Mode for autonomous assistance and Copilot Edits that might just replace Cursor in my workflow. The dev tools space keeps getting more interesting.

3. JavaScript Temporal is coming
   Finally, a proper solution for time handling in JavaScript! The examples show how Temporal will make our datetime headaches disappear with immutable, timezone-aware objects.

4. Truck maker Nikola nears bankruptcy
   Reality check for the former SPAC darling: $200M quarterly loss shows building alternative fuel trucks isn’t as simple as PowerPoint slides suggested.

5. $SPX January in context
   @northmantrader’s chart tells the story: market’s coiling up for a significant move. The question is which direction?

📚 This week’s deep dives at the intersection of tech, investing, and innovation:

1. Richer Wiser Happier: Bill Priest on Strategy
   Reflecting on Priest’s insight: “The goal is winning, but you have to answer two questions: where to play and how to win.” Simple yet profound framework for any strategic decision.

2. The Short Case for NVDA
   Timely analysis of NVIDIA’s position in AI hardware, especially relevant with DeepSeek R1’s emergence. The technical deep-dive into DeepSeek’s architectural differences makes this particularly insightful.

3. DeepSeek R1 Breakdown
   Essential 5-minute primer on DeepSeek R1 and its implications. Clear explanation of both the what and “so what” - perfect for understanding this AI milestone.

4. Building a Smartwatch from Scratch
   Fascinating DIY journey: a father builds a custom smartwatch because Apple Watch wasn’t optimized enough for his son’s continuous glucose monitoring. Innovation driven by necessity at its finest.

5. UV as Your Shebang Line
   Smart trick for Python developers: transform your scripts into standalone utilities using UV. This package manager keeps impressing with its versatility.

What tech developments caught your eye this week? Share below 👇

#Tech #AI #Innovation #Engineering

What I’m reading this week

📚 Weekly brain food! Here’s what got me thinking this week:

1. Taking a look at compression algorithms
   Abboud’s deep dive into DEFLATE brings back memories from CS fundamentals. It’s remarkable how this algorithm still powers our daily tools - from GZIP to PNG files.

2. Garmin’s ~$40B Pivot
   When GPS went mainstream on phones, Garmin chose specialization over competition. The result? A $40B success story in fitness wearables and outdoor tech. Brilliant example of turning disruption into opportunity.

3. Why Solana is outperforming Ethereum
   26,500% outperformance isn’t just about tech - it’s about narrative. Solana’s story of speed, security, and scale is clearly resonating with institutional money.

4. Tuist launches a package registry
   Finally! Swift gets its “npm moment” with Tuist’s new package registry. This could be the convenience boost the ecosystem needed.

5. Hack CarPlay for a McLaren
   When a McLaren 720S meets DIY hacking: Bell’s Raspberry Pi solution brings wireless CarPlay to his supercar. Peak tech enthusiasm right here.

What caught your eye this week? Share below 👇

#Technology #Innovation #Engineering #Crypto #Development

What I’m reading this week

📚 Weekly brain food! Here’s what got me thinking this week:

1. A regex chess engine
   This one blew my mind - Carlini built a chess engine using just regular expressions! It’s one of those projects that makes you rethink what’s possible with basic tools. Love seeing developers push simple primitives to their limits.

2. Obvious things C should do
   Found myself vigorously nodding along to Bright’s suggestions. Compile-time function evaluation in C? Yes, please! Some really solid proposals here that could modernize C while keeping its spirit intact.

3. Oh shit git
   Do yourself a favor and bookmark this one if you use git (and who doesn’t these days?). Pro tip: try “git reflog” when you need to see the complete history of all references. Has saved my bacon more than once!

4. Is the world becoming insurable?
   This hits close to home. Having dealt with California’s FAIR plan myself, the rising insurance challenges from climate change are very real. Really feeling for our LA neighbors dealing with the current fires. This isn’t just academic discussion anymore.

5. Core CPI rises less than forecast
   Markets liked the cooler CPI print this week (hello, green indexes! 📈). My take? This might give the Fed room for more easing, potentially fueling one final leg up in this bull market… before a serious correction hits. Keep your eyes peeled.

What caught your attention this week? Drop your thoughts below 👇

What I’m reading this week

📚 Hey! Here’s what caught my eye this week - sharing in case you find these interesting too:

1. How I program with LLMs
   I’ve been using Cursor for my side projects lately, and this article was super helpful. Picked up a few new tips that I’m excited to try out.

2. More Speech and Fewer Mistakes
   Been following Meta’s policy changes closely, and the timing of this one really caught my attention. Pretty interesting move considering what’s happening in the US political landscape.

3. Smells like American spirit
   Really enjoyed this piece from Slate about great salespeople. It reminded me of something I’ve learned over the years: you can have the best product in the world, but without good salesmanship, it won’t go far.

4. Python Concurrency: Threads, Processes, and asyncio Explained
   If you’ve been wanting to get better at Python concurrency (like I have), this is a really clear explanation. Found it super helpful for understanding the basics.

5. Correlation between $TNX and $IWM
   Quick heads up for anyone investing in small/mid caps: worth keeping an eye on those US 10-year yields. Been following this correlation and it’s pretty revealing.

What’s on your reading list? Would love to hear what you’re finding interesting!

#TechInsights #Innovation #Finance #Programming

In the fast-paced world of software development, we often fall into the trap of grand, sweeping changes. We dream of complete overhauls, ground-up rewrites, and revolutionary new systems. But here’s a hard truth: these all-or-nothing propositions are often a recipe for disaster.

Let’s talk about incrementality. It’s not glamorous. It doesn’t make for exciting presentations or bold mission statements. But it’s the secret weapon of successful engineering teams everywhere.

Consider a recent example from my time at Airbnb. We aimed to add a critical feature to our device testing lab for end-to-end testing, promising faster and more comprehensive test runs. The project hinged on the edge networking team developing a safe VPN tunneling solution, initially estimated to take one quarter. However, this dependency stretched to nine months due to unforeseen complexities, security challenges, and competing priorities, leaving our e2e testing project in limbo and causing cascading delays across multiple teams.

This experience starkly illustrates the pitfalls of all-or-nothing thinking in software engineering. Complex systems are prone to unexpected challenges and shifting priorities. Our mistake wasn’t in trusting the edge networking team, but in failing to plan for contingencies and interim solutions. It underscores the critical need for incremental progress and flexible planning, breaking large projects into smaller, independently valuable pieces that can deliver benefits even when other components face delays.

This isn’t just an Airbnb problem. It’s an industry-wide issue. We get caught up in the allure of the perfect solution, the comprehensive fix. We convince ourselves that if we just wait a little longer, we’ll have everything we need to do it “right.”

But software doesn’t work that way. Neither does business.

Instead of waiting for the perfect solution, we should have broken the project into smaller, manageable pieces. We could have implemented an interim solution, something that got us 80% of the way there without the network dependency. Then, we could have iterated, improved, and adapted as new capabilities became available.

This approach does more than just deliver results faster. It de-risks the entire project. By shipping incremental improvements, we get real-world feedback earlier. We catch issues before they become critical. We build momentum and maintain team morale.

Incrementality isn’t about lowering our standards or settling for less. It’s about recognizing that progress is better than perfection. It’s about understanding that in the real world, requirements change, technologies evolve, and businesses pivot. By working incrementally, we stay flexible and responsive to these changes.

So how do we put this into practice?

1. Break big projects into smaller, independently valuable pieces.
2. Prioritize these pieces based on immediate value and feasibility.
3. Ship early and often, even if it means using temporary solutions.
4. Gather feedback and iterate rapidly.
5. Be transparent about the incremental nature of the work to set proper expectations.

Remember, every line of code you ship is a line of code that’s providing value, being tested, and moving you closer to your ultimate goal. Every feature you roll out is an opportunity to learn and improve.

The next time you’re faced with a big project or a daunting dependency, resist the urge to wait for everything to be perfect. Instead, ask yourself: “What can we do right now, with what we have, to move in the right direction?”

Incrementality isn’t just a development strategy. It’s a mindset. Embrace it, and watch as your projects start delivering value sooner, adapting to change more easily, and ultimately succeeding more often.

In software engineering, as in life, the journey of a thousand miles begins with a single step. So take that step. Then take another. Before you know it, you’ll have traveled further than you ever thought possible.

Welcome! I am a Javascript, iOS and Technology enthusiast. I did iPhone stuff at Apple for a while. Now at Facebook where I tech lead teams.
I constantly share relevant iOS, JS, and Node.js tips and tricks. This is the place!