This is a poor ad for Spotify engineering:
Calling code analysis and test generation “I/O” is nonsense.
The 90% claim does not measure the cost of doing the same task correctly.
There is no published measurement of the quality trade-off.
The benchmark can reward failure.
Spotify cut Claude Code token usage by 90% with a few simple changes
Here’s the quick breakdown:
- Keep Claude for tasks that actually require reasoning
- Route large file reads to cheaper models like Gemini 2.5 Flash
- Use PreToolUse hooks to automatically intercept expensive reads
- Return only the relevant context back to Claude
- Delegate boilerplate, tests, configs, and repetitive code
Don’t spend frontier model tokens on work that doesn’t require frontier model intelligence
Link: https://t.co/oAM150SUW1
If the West really cared about de-escalation, they’d tell Pakistan: stop the provocation or lose IMF funds.
That alone would likely end the conflict. But they won’t, Pakistan is their tool to keep India in check. The US cares even less because Pakistan’s IMF cash indirectly circles back into buying weapons, a major chunk of which comes from them.
The global peace lobby is a farce. Not one word to the IMF. So yes, we’re on our own. But we’ll prevail.
I've been at @Google 12 years today.
Here are 10 lessons I've learned that may help others:
1️⃣ Embrace lifelong learning
Continuous learning is the heartbeat of a thriving career. Stay endlessly curious.
Write about what you learn - the process of explaining concepts to others will deepen your own understanding and uncover gaps in your knowledge. Have the humility to admit when you don't know something, and model a growth mindset for your team. Invest in your own growth, and inspire others to do the same.
2️⃣ Put users front and center
The best engineers are user-obsessed. Let customer needs guide every decision and prioritization.
Always start with user needs and work backwards to the right solutions. Seek to understand the real human problems your work solves.
3️⃣ Collaborate to amplify impact
No engineer is an island. The most impressive feats in our field are accomplished by teams, not individuals.
Shift from a "me" to a "we" mindset. Focus on collaborating, sharing knowledge, and uplifting those around you.
4️⃣ Just start. You can edit a bad page, not a blank one.
Don't let perfectionism paralyze you. Start by taking action, even if it's not flawless.
Get your minimum viable product out there. Then, focus on doing it right. Refine your approach, fix bugs, and optimize for quality. Finally, seek ways to do it better.
5️⃣ Master the art of influence
The most effective engineers are also skilled influencers. They build bridges and buy-in.
Identify key stakeholders, decision-makers, and influencers. Understand their priorities, motivations, and communication styles.
6️⃣ Think strategically
Understand what matters most to the business and your users. Focus on outcomes over just outputs.
Develop the ability to think strategically and connect the dots across projects, teams, and organizations. Anticipate downstream implications of decisions and architecture choices.
7️⃣ Focus on what you can control
Concentrate on what's within your sphere of influence.
You can't control everything, but you can always control your response. Zero in on actions you can actually take to move forward, no matter how small.
8️⃣ Communicate with clarity
The ability to distill complexity is a hallmark of great engineers.
Strive to communicate clearly in all you do. Tailor your communication style to your audience. Seek to listen and understand first, then to be understood.
9️⃣ Build bridges, not silos
The most impactful work happens at the intersections.
Seek to understand others' perspectives, needs, and constraints. Find ways to align and create win-win solutions for everyone.
🔟 Invest in your wellbeing
Sustainable high performance requires intentional renewal. Prioritize balance and resilience.
Set boundaries. Take breaks. Craft a life of meaning and joy beyond your identity as an engineer.
I hope these lessons help others. May we continue to learn, lead, and inspire, one step at a time.
~ Addy
I experimented a bit more with async_hooks in @nodejs for API mocking and here are my thoughts.
1. Hooks are powerful. I love the concept of (semi-)public API to hook into Node's internals, which includes HTTPINCOMINGMESSAGE.
2. Hooks lack documentation. It's a bit unclear which events hooks even support. There's nothing about it in the docs, and the most straightforward way to figure that out was to come up with a use case, enable hooks, and just observe what gets "emitted".
3. "console.log" not working in hooks is confusing. Logging something out emits its own hook, so if you decide to observe what gets emitted in a general listener, you will create an infinite loop. The official example recommends fs.write() and process instead.
4. I like the granularity of the network events. You get the TCP events, you get the Incoming/Outgoing message events. Those are nice. But...
5. My main concern is that those network events are too low-level. They will work fantastically if you are implementing the http module-based interception. This should cover like 75% of use cases. But it won't cover everything, and will significantly fall short when attempting to mock request APIs built on top of the http module, like XMLHttpRequest in JSDOM. You won't have access to those APIs (naturally), and so some request details will be lost on you, like whether the request was made with or without "withCredentials" enabled.
As a summary, async_hooks are powerful. I will keep a close eye on them to see what they will offer in the future. But as of now, they are not sufficient to implement comprehensive request interception on top of them. Alas, we still have to resort to augmenting request-issuing modules. As a benefit, however, we always get the right control layer and access to the precise request options, which is often what you want when describing network.
The Server Component Treatment 🧵
Let's take normal React code and convert to RSCs.
1 - Rendering on the server
The server endpoint returns a todo object, and the client component renders it.
But what if the todo object came already rendered from the server?
The secret that most devs hate to admit is that code is a means to an end and ultimately quality doesn’t matter unless it gets in the way of turning a profit
Ask yourself if you’re more valuable if you refactor old code or if you create a new feature that makes more money
You might like to think that “refactoring code will make it easier to make more money!”
Sometimes that’s true, but most devs will use refactoring as an excuse because it’s much easier than creating something valuable
If you practice creating value over rewriting code, you will always be valuable
Let's push it further: you should always have this on when developing user interfaces in the browser.
Catch those race conditions, flakiness, and other network latency-related issues while developing. Full control over the network with @ApiMocking.