Tiny Anna Das 🙋🏽‍♀️

@karpathy Maybe you having a lot of interests keeps them guessing

One common issue with personalization in all LLMs is how distracting memory seems to be for the models. A single question from 2 months ago about some topic can keep coming up as some kind of a deep interest of mine with undue mentions in perpetuity. Some kind of trying too hard.

If you want to get hired, open the screen recorder on your computer and create a short, tailored intro / pitch video to the company you want to get an interview with. DM this video along with a short introduction and link to your 1 page resume to someone in the company responsible for the role you are hiring for. Most importantly, only do this for roles you actually think you’re capable of. It will work 1,000x better than this slop.

@anuraggoel The code that launched straight to the cloud

AI is quietly deprecating GitHub. Agents do not need branches, PRs, or CI/CD rituals. They want to ship code straight to the cloud. The rsync renaissance is here. High availability. Zero bloat. Faster loops.

@neural_avb Things people do for reach. Pathetic

Okay I'll bite. You are one of the most insufferable accounts here. Openly hateful. You don't know India. Shut your mouth and stay away. Stick to jokes about your country, wherever you might be from.

@Prathkum Learn SD and DS!!

Most software in the past existed because someone technical decided a problem was worth solving. Now the person facing the problem can build the solution themselves. I am not saying that developers are no longer relevant. Vibe coding works when you are solving a problem for yourself. Engineers and developers will still be relevant in solving problems at scale.

Django taught me to use JWT. FastAPI taught me what JWT actually is. I spent three years doing auth in Django with SimpleJWT. Hit /api/token/, get tokens back, done. request.user just worked. I never called jwt.encode() once. Never wrote a get_current_user function. Never thought about what was actually inside the token. Then I built something in FastAPI. Suddenly I had to write everything myself, the payload, the expiry, the hashing, the dependency that decodes the token on every request, the error handling when it's expired or tampered with. It was more code. It was also the first time I actually understood what I'd been using. The difference isn't really about which is better. It's about what each framework thinks your job is. Django says: here's a working auth system, configure it in settings.py. FastAPI says: here are the primitives, wire it yourself. One gives you speed. The other gives you understanding. The dangerous assumption is thinking you have both when you only configured one. If you've only ever done JWT in Django, try implementing it from scratch in FastAPI once. Not because it's more practical. Because you'll come back to Django knowing exactly what SimpleJWT is doing behind the scenes, and that knowledge will matter the next time something breaks in production at 2am. The best engineers I've met aren't the ones who know the most frameworks. They're the ones who know what the frameworks are hiding.

The US military used Claude for target selection and intelligence analysis during Iran airstrikes. Hours later, Trump told agencies to stop using it, via Truth Social. Not an executive order. A post. The Pentagon followed by labeling Anthropic a "supply chain risk to national security", the same designation reserved for foreign adversaries,because the company refused to enable autonomous weapons and mass surveillance. Same day. OpenAI signed a Pentagon deal. The message to every AI company watching: build the kill switch, get the contract. refuse, become the threat.

Solved Leetcode 76. Minimum Window Substring today. My first Leetcode "Hard" problem. "Solved" is doing a lot of heavy lifting in that sentence. Here's what actually happened: Watched a YouTube video. Didn't get it. Rewatched. Still didn't get it. Rewatched again but slower this time, like slowing down the video would somehow slow down the algorithm too. It didn't. Asked Claude to explain it step by step. Understood 80% of it. The other 20% is somewhere between my left pointer and my right pointer, and I've chosen to leave it there. But here's the thing, the code runs. All test cases pass. And I understand most of why. That's not failure. That's just how it actually works. Nobody tells you this, but the first time you solve a hard problem, it looks less like a breakthrough and more like: watch, rewatch, copy, break it, fix it, ask someone, half-understand, submit, pass, stare at it, still half-understand, post on LinkedIn pretending you get it. I'm skipping that last part. I half-get it and I'm posting anyway. 68 down. 3,792 to go. If you read this far, I hope every hard problem you attempt makes slightly more sense than it did five YouTube rewatches ago. 😊

Visualize step-by-step If you’re learning algorithms and feel dumb sometimes, this helps more than you think ! @neetcode1 @

Excerpts from the Diary of a Full-Stack Developer I’ve been doing UI work for the past few weeks, even though I’m naturally more of a backend person. And honestly… it’s been heavy. What makes it tougher is the review cycle. Before a UI gets approved, many people share their opinions, and I end up reworking the same screens again and again. Even after several rounds, nothing feels final. Some days it feels like I’m getting duller, not better. Like the work is draining the part of me that usually enjoys building things.

If you’re struggling to start Data Structures & Algorithms, read this. Let me show you a simple stat that changed how I look at it. First, what is NeetCode? NeetCode is a popular learning platform that curates the most important DSA problems (mostly from LeetCode) and organizes them into a clear roadmap, so you’re not randomly solving questions. Now the interesting part 👇 According to data from neetcode.io: - Solving just 11 questions already puts you in the top ~26% of users - Solving 25+ questions puts you in the top ~8.5% of users Read that again. You don’t need 300 problems. You don’t need to be a “DSA god”. You just need to start. Most people never even cross 10 problems. Consistency alone separates you. If you’ve been delaying your DSA journey because it feels overwhelming - this is your sign. Open NeetCode. Pick one problem. Start today. P.S. I am in the top 15.3% by the way 😇

Fixed a critical JWT token refresh race condition that was logging users out unexpectedly Ever had users complain about being randomly logged out during active sessions? We found the culprit: a race condition in our token refresh logic. The Problem: When multiple API calls failed simultaneously (like on page load with 5+ requests), each one tried to refresh the JWT token independently. This caused: - Multiple refresh requests hitting the server at once - Token invalidation when the backend consumed the refresh token - Users getting logged out unexpectedly - Poor UX during active sessions Implemented a mutex pattern to ensure only one token refresh happens at a time. All concurrent requests now wait for the same refresh operation instead of creating duplicate requests. The Impact: - Zero unexpected logouts - Reduced API calls (1 refresh instead of N) - Better performance and user experience - Cleaner, more predictable code

Cursor 2025, the wrap!

@jack When we see the creations we acknowledge the creator 🙌

the act of creation is the only thing that justifies existence

Progress in any initiative is limited by how fast you can fail, recover, and come back at it again. - Tried to solve a LeetCode problem but couldn’t do it. - Watched a solution video and didn’t understand it. - Watched it again—still couldn’t get it. - Watched it 4–5 times, giving myself time in between. - Slowly, things started to make sense.

@popovicu94 Same call. different kernel paths.

The Unix philosophy is "Everything is a file." Sockets are the ultimate proof. When you call socket(), the kernel creates a communication endpoint. To your app, sending data to Tokyo is identical to writing to a text file on your desktop. You just write() bytes to that ID.

Your entire Linux network connection is just one thing: An integer. When you connect to a server, Linux hands you a simple number: a file descriptor. This happens via syscall socket (#41 on x86_64). Here is how the kernel turns the world into a file. 🧵👇

Most people will never admit this about web development: the biggest lie in 2025 is that "AI will replace devs." It’s bullshit - but the truth is far scarier. 1/20 ↓

@popovicu94 Linux optimizes for developers and ecosystems. BSD/macOS optimize for tight OS control and security.

Linux makes a guarantee that almost no other Unix-like OS dares to make: The raw system calls are the public API. If you look at macOS or OpenBSD, the "kernel ABI" is effectively private. The only supported way to talk to the kernel is through the system library (libc/libSystem). If you bypass libc and invoke a syscall instruction directly, they offer no guarantee it won't break in the next update. Linux takes the opposite stance. write syscall on x86_64 is write, and it will be write forever. This architectural decision is the hidden reason why languages like Go feel so "native" on Linux compared to other platforms. When you compile a pure Go program on Linux without cgo, the toolchain doesn't bother linking against glibc or musl. It knows the kernel protocols, so it just generates the raw assembly to talk directly to the OS. The result? You get a static binary that runs on Ubuntu, Fedora, Alpine, or your own home-cooked distro, with zero userspace dependencies. Try that on macOS, and Go is forced to link dynamically against libSystem. It can't trust the kernel interface to stay stable. Go learned this the hard way. For years, Go made raw syscalls on macOS just like it does on Linux. Then Apple changed things, binaries broke, and Go had to capitulate. Now every Go binary on macOS links libSystem. OpenBSD is even more extreme. Theo de Raadt has said "we here at OpenBSD are the kings of ABI-instability." They actively change syscall numbers and signatures between releases as a security hardening measure. Their advice? "Program to the API rather than the ABI." This split exists because of how the projects are managed. macOS and the BSDs ship a complete OS (kernel + userland). They own libc, so they can change the syscalls underneath it whenever they want. Linux is just the kernel. Linux doesn't control your userland, so it has to give you a stable way to talk to it that doesn't rely on a specific version of a library. It raises the question: Is the "libc is the API" model actually safer for evolution, or is the Linux "stable syscalls" model the ultimate freedom for developers? Check out some interesting GitHub links from the Go project below! 👇

@popovicu94 @attratore 😂

@attratore @tinyannadas

Everyone should know by now that I think Bazel is the best build system. And I've been playing with Zig. I'm playing a bit with putting those two together, and it's mostly AI writing the code. Check the demo below! Let me know what you think. 🤔 Good stuff or blasphemy?!