vikrant

Just shipped work-bench.dev - a terminal-inspired PWA with 21+ developer tools! Also supports Jupyter-style notebook for Same developer tools. Thread below 👇 RT if you find this useful! #DevTools #WebDev

Dont blindly follow Claude (or any coding Agent)! - Work in plan mode - review the plan before executing - Take help from another independent Agent to review the plan - and offer alternatives

"I'm actually getting chills right now , just thinking about it, my palms are sweating!" - Commander Reid Wiseman Our brain is so conditioned for human-scale environments, familiar distances and sizes. Looking at it from comfort of home itself in a way reduces attachment to trivial problems and gives a deep appreciation for Earth. In a way it as a spiritual experience, even if one is not religious. "There's a lot that our brains have to process," Wiseman added. "Human minds shouldn't have to go through what these just went through, and it is a true gift." science.nasa.gov/earth/earth-ob…

Through my eyes | Through my dog's eyes Download Pawvision here - apps.apple.com/us/app/pawvisi…

Through my eyes | Through my dog's eyes Download Pawvision here - apps.apple.com/us/app/pawvisi…

POV: Senior Agentic Engineer

Context engineering is powerful I agree, and it is making some otherwise "clerical" part redundant for sure. That said based on my experience so far , AI accelerate exploration in design step,But human oversight in design doesn’t disappear. Atleast not until models can reason deeply about system constraints, humans still need to provide the guardrails especially for systems that need determinism. financial systems, identity, safety infrastructure etc,

This post from @boristane left me shook. What a powerful call to action. "The SDLC is dead. The new skill is context engineering. The new safety net is observability." "When every feature took weeks, you had to decide upfront what to build. That constraint is gone." "Design is becoming something you discover by giving the agent the right context, not something you dictate ahead of time." "The pull request flow needs to go. I was never a fan, but now it’s just a relic of the past." "Monitoring is the only stage of the SDLC that survives. And it doesn’t just survive, it becomes the foundation everything else rests on." Brilliant stuff. boristane.com/blog/the-softw…

dbdb.io is like the IMDB of databases! 1000+ dbs to choose from! That said I think PostgreSQL is the universal default DB !

Code migrations are one of the most expensive, soul-crushing line items in enterprise engineering. A typical framework migration (React class to hooks, Jest to Vitest, Angular to React) takes a team of 3-5 engineers somewhere between 2-6 months. At $150-200/hr loaded cost, that’s $200K-$500K per migration for a mid-size codebase. And most companies have a backlog of 5-10 migrations they’ve been avoiding for years because the math never works. /batch rewrites the math entirely. Each agent gets its own git worktree. Full isolation. It writes the code, runs the tests, and opens a PR. Dozens of these running in parallel means what used to take a team a quarter now takes an afternoon of review. The serialization bottleneck is gone. Migrations have always been constrained by the fact that one human can only touch one file at a time, needs context on the codebase, and gets fatigued by the repetition. The work itself was never intellectually hard. It was volumetrically hard. And volume is exactly what parallelized agents solve. This changes how engineering leaders think about technical debt. Every CTO has a spreadsheet of migrations they’ve been deferring because the ROI never justified pulling engineers off feature work. /batch turns those from “someday” projects into Tuesday afternoon tasks. Anthropic is building the infra layer that makes AI agents useful for real engineering work, not demos. And /batch is the clearest signal yet that they understand the actual bottleneck: developers don’t need help writing new code nearly as much as they need help moving old code forward.

Scale changes the good practice! At modest scale, joins are often great. infact often a productivity win. But at scale they can become a reliability risk! The problem shows up (at high scale) when join-heavy queries land on critical paths. And if joins are generated by ORMs, than even more tricky. this engg post by openAI highlight that pain point openai.com/index/scaling-… .

The traits listed resonate ,especially autonomy + experimentation. Two thoughts that come to mind: - Even great managers struggle in a misaligned environment.If the system doesn’t allow autonomy, tolerates no experimentation, or overloads teams with process, the manager’s impact gets constrained quickly. - There’s also a scaling angle.Too many “great managers” managing the same surface area can become counterproductive. Clarity of ownership matters. Otherwise, it turns into too many cooks in the room.

What makes a great manager of software engineers? A study showed the traits of great tech managers at Microsoft. Technical skills are required, but they alone are not a sign of greatness. Other things that mattered were: - availability - give autonomy - support experimentation - set clear ways to do things Read the whole paper here: thomas-zimmermann.com/publications/f…

Through my eyes | Through my dog's eyes Download Pawvision here - apps.apple.com/us/app/pawvisi…

𝐒𝐡𝐢𝐩𝐩𝐢𝐧𝐠: 𝐓𝐡𝐫𝐨𝐮𝐠𝐡𝐁𝐚𝐛𝐲𝐄𝐲𝐞𝐬. (only on IPhone) A few months ago I built PawVision, an app that simulates how dogs perceive the world. It was meant to be a fun experiment. Color perception. Contrast tuning. A little science. A little curiosity. Then something interesting happened. A user reached out and said: “This is amazing. You should make something like this for newborn babies.” That message stayed with me. it revealed something deeper, curiosity about perception itself. Newborn babies don’t see the world the way we do. Their vision is blurry. High contrast matters more than color. Focus range is limited. Edges are stronger than gradients. Today, I’m shipping: ThroughBabyEyes. now live on the App Store- apps.apple.com/us/app/through… An app that lets you simulate how newborn, infant, toddler vision works using scientifically inspired filters applied in real time. 𝐏𝐒: 𝐈𝐭’𝐬 𝐧𝐨𝐭 𝐦𝐞𝐝𝐢𝐜𝐚𝐥 𝐬𝐨𝐟𝐭𝐰𝐚𝐫𝐞. 𝐈𝐭’𝐬 𝐧𝐨𝐭 𝐝𝐢𝐚𝐠𝐧𝐨𝐬𝐭𝐢𝐜. 𝐈𝐭’𝐬 𝐣𝐮𝐬𝐭 𝐩𝐞𝐫𝐬𝐩𝐞𝐜𝐭𝐢𝐯𝐞

𝐀𝐥𝐠𝐨𝐫𝐢𝐭𝐡𝐦𝐬 𝐀𝐫𝐞 𝐉𝐮𝐬𝐭 𝐑𝐞𝐚𝐥 𝐋𝐢𝐟𝐞, 𝐅𝐨𝐫𝐦𝐚𝐥𝐢𝐳𝐞𝐝 We often struggle to connect algorithms to the real world. But most algorithms start as real-world problems. If you pause long enough, patterns begin to emerge. In this post, I want to walk through one such example , where a very ordinary, human problem quietly turns into a classic algorithm we all know. 𝐑𝐞𝐚𝐥 𝐋𝐢𝐟𝐞 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 A man runs a mid-sized auditorium. Before every show, he faces the same question: 𝑯𝒐𝒘 𝒔𝒉𝒐𝒖𝒍𝒅 𝒔𝒆𝒂𝒕𝒊𝒏𝒈, 𝒂𝒊𝒔𝒍𝒆𝒔, 𝒂𝒏𝒅 𝒔𝒂𝒇𝒆𝒕𝒚 𝒔𝒕𝒂𝒇𝒇 𝒃𝒆 𝒂𝒓𝒓𝒂𝒏𝒈𝒆𝒅? He doesn’t know the audience in advance. Planning for every edge case wastes resources.Planning for an “average” audience doesn’t really work either. 𝐇𝐨𝐰 𝐇𝐞 𝐒𝐨𝐥𝐯𝐞𝐝 𝐈𝐭? Over time, he starts noticing patterns. Certain age and body-type combinations show up far more often than others. So he begins planning resources around the few audience types that appear most frequently, while keeping a small buffer for the rest. Once he does that, comfort improves. Operations get smoother. 𝐖𝐡𝐢𝐜𝐡 𝐀𝐥𝐠𝐨𝐫𝐢𝐭𝐡𝐦 𝐈𝐬 𝐓𝐡𝐢𝐬? If you step back, this maps almost perfectly to the Top K Frequent Elements problem.We usually solve it for integers in a list. Here, the “elements” are audience profiles age and body-type combinations. First, define what an audience profile looks like: case class Profile(age: Int, height: Int, weight: Int) What we want is a function like this: def topKFrequentProfiles(profiles: List[Profile], k: Int): List[Profile] It takes historical audience data and returns the few profiles that show up most often. The approach is straightforward: Count how often each profile appears → Keep only the most frequent ones using a small heap → Ignore the rest 𝐂𝐥𝐨𝐬𝐢𝐧𝐠 𝐓𝐡𝐨𝐮𝐠𝐡𝐭 The interesting part isn’t the code . It’s realizing that many algorithms already exist in the real world. We just give them names later. Once you start seeing problems this way, algorithms stop feeling abstract. They start feeling inevitable.

“writing prompts” is becoming "training your future self". Last week, as an experiment, I asked Claude (the coding agent I use) to write a prompt for building a brand-new app. I didn’t give it a template. I asked it to study another project I had already built, read the source code, absorb the structure, decisions, and tradeoffs and then generate a prompt that could be used to build a different app from scratch (after I described the new idea). Claude produced a ~400-line prompt: gist.github.com/tuachotu/f2c49… That prompt created an iOS app that was ~95% functional in under 4 minutes. The agent didn’t just learn APIs or patterns, it learned me. It inferred priorities, shortcuts, boundaries, and taste from artifact behavior. And the best part? That app is already in App Store review.

𝐋𝐞𝐬𝐬𝐨𝐧 𝐟𝐫𝐨𝐦 𝐚 𝐑𝐨𝐬𝐞 𝐁𝐮𝐝 Late this January, on my morning walk, I noticed a rose bush starting to bud. This made me think: Winter is not yet over, temp is going to dip.This tender growth may die back. If you imagine what this plant may be thinking. One thing is sure, it was not saying “It’s spring.” It must be thinking : “The air is warm. The days are getting longer. Let’s respond to signals.” In few weeks, when winter is back, bud will be dead. The plant won’t feel regret. It just absorbs the loss and waits again. 𝐇𝐚𝐫𝐝 𝐭𝐢𝐦𝐞𝐬 𝐟𝐨𝐫 𝐩𝐞𝐨𝐩𝐥𝐞 𝐟𝐞𝐞𝐥 𝐬𝐢𝐦𝐢𝐥𝐚𝐫. Social Unrest, Problems at home, job disappears, Savings shrink they all are same. The signals we relied on: “stability, predictability, fairness”, go stale. It can feel like we misread everything. But often, we didn’t. The ground shifts under assumptions we built carefully. We acted on the best signals available at the time. Like plant we don’t need certainty to endure. we just need enough strength to wait, reset, and grow again when conditions allow Spring will come again!

𝐖𝐡𝐞𝐧 𝐲𝐨𝐮 𝐡𝐚𝐯𝐞 𝐭𝐢𝐦𝐞, 𝐰𝐚𝐭𝐜𝐡 𝐭𝐡𝐞 𝐚𝐠𝐞𝐧𝐭 𝐰𝐨𝐫𝐤 Not what they do, but how they do it , can be eye-opening. Today was a small example. 𝐏𝐫𝐨𝐛𝐥𝐞𝐦: Xcode app icon needed fixing. My brain went straight to: export → resize tool → re-import. I asked Claude to do it. 𝐀𝐠𝐞𝐧𝐭'𝐬 𝐒𝐨𝐥𝐮𝐭𝐢𝐨𝐧 : The agent didn’t “code” anything. It casually reached into the OS and used sips, a built-in macOS utility I didn’t even know existed on my machine. Resized the image in place. Moved on. We are living in a very interesting time!

Shipped Pawvision 3.0 today. It’s live on the App Store now. Working with coding agents makes you very productive and you can get a lot done in little time as long as you know what you want. In other words , what impacts the speed (or makes you slow in AI age is - deciding what mattered, - cutting scope without regret, - and being precise enough that the output didn’t drift. We all need to learn recognizing when “good enough” was the responsible choice. BTW: please download the app if you use iPhone . Pawvision explores how animals perceive the world using real-time camera simulations ,dog vision, bird vision, bee vision, and snake vision all processed on-device. apps.apple.com/us/app/pawvisi…

Curiosity > Evaluation. There’s a pattern I keep noticing. We often spend more time trying to find what a person doesn’t know than understanding what they do know. Once you see it, it’s hard to ignore. - Meetings reward critique, not synthesis. - Interviews reward elimination, not discovery. - Social media rewards dunking, not depth A Better Way : In a professional setting , especially when you’re operating inside a team or building one, optimizing for signal beats gap-hunting on almost every axis that matters. Strong teams aren’t built by minimizing individual gaps. They’re built by recognizing signal: how someone thinks, what they’ve learned through experience, and where they consistently create impact. No one knows everything. High-performing teams succeed by stacking strengths, not by minimizing individual blind spots When I am participating a discussion (team meeting or interview) , My bias is simple: “optimize for signal, not for gotchas.”

As I am working integrating one of my backend with LLM, I am realizing that although LLMs speak natural language, they behave far better as structured reasoning engines. Backend Systems operate on structure. Everyone should consider LLM as A function that transforms structured input → structured output, using natural language internally. Give LLM strict input and demand strict output. Always ask for JSON & Validate aggressively. Natural language is an implementation detail, not the interface.