Vishal Builds

Claude just killed Microsoft Teams and Google Meet 💀

Gemini 4 Hydrogen is here 🔥 ⚡ 2.3× faster than GPT-6.1 Terra ⚡ 2.5× faster than Claude Sonnet 5.5 💰 1.6× cheaper than GPT 💰 8.6× cheaper than Claude 🧠 Scores 51 in just 6 min vs GPT's 14 min 🧠 Scores 54 in just 13 min vs Claude's 32.5 min Faster. Cheaper. Smarter Excited to test it.

been building voice agents lately, and one thing I kept running into was how messy things get when app state changes and you have to keep updating the agent's prompts and tools 😭 found an open-source tool called Curb.js by KugelAudio. It uses React components to manage the agent's context and available tools as your app changes. wanted to try it out, so built a voice copilot that investigates a simulated checkout outage and only unlocks rollback after verification. Here's the demo 👇

Why will AI agents need a completely new kind of web search, instead of just using Google 🤔 Parag Agrawal had a really interesting explanation for this. We've spent decades building search around how humans use the internet, but agents behave so differently that the whole infra might need to change. Think about how we use Google. We type a few random words, get some links, click around, read a bit, go back, search again. Half the time we don't even know exactly what we're looking for until we start browsing. That's what search engines have spent decades optimizing for. But agents don't work like that. An agent can send an entire task's worth of context in a single query. And it doesn't need 10 blue links to click through. It needs useful information it can put into its context window, reason over, and figure out what to do next. So, both the input and output of search change. Then there's the scale problem. If agents end up using the web 1000x more than humans, are we really going to build 1000x the search infrastructure Google has today? Probably not. We'd need to rethink how search itself is built. And the timing is interesting too. GPUs are getting more capable, and we're getting better at distilling intelligence into smaller models. So, building efficient search and ranking systems in entirely new ways is becoming possible. Then there's latency, which I hadn't thought about either. For us, a Google search taking 500ms feels fine. But for a voice agent, that same delay can feel awkward. You'd want something closer to 50–200ms. Meanwhile, an agent researching something overnight could spend an hour searching. Nobody's waiting for it. So even what counts as "fast" depends on what the agent is doing. And the economics change too. Human search makes enough money per query to support its infrastructure. Agent searches could happen far more frequently while bringing in much less revenue per query. The same compute costs might not make sense anymore. That's what made the whole thing click for me. It's not just that agents will search more. They ask differently, consume information differently, and need different tradeoffs between speed, cost, and compute. We've spent decades building search for humans clicking through websites. Now agents might become some of the biggest users of the web, and they don't even interact with it the same way we do lol Makes me wonder how many other things we've built around human behavior that we'll need to rethink once agents become the users. CRAZY TIMES AHEAD 🔥

WTF 🤯 Imagine catching hidden security bugs in apps like WhatsApp or banking apps before hackers ever find them. Now imagine doing the same for hospital machines, cars, and even power grids. Google just took a HUGE step toward making this possible. They used AI to mathematically verify real encryption software in just 4 weeks 🔥 Lemme explain why this is BIG, in simple words 👇 Think about how much we trust software every day. We send private messages, transfer money, store personal information, and just expect everything to be secure. But how do we actually know? Normally, developers test their code, look for bugs, and try different ways to break it. The problem is that even if thousands of tests pass, there could still be some hidden mistake nobody thought to check. There's another way to check software called formal verification. Basically, instead of just testing whether something works, you use math to PROVE that certain things can't go wrong. Sounds great, right? The problem is that doing this for complicated real-world software is insanely difficult. It can take experts years. And this is where DeepMind's research gets interesting. They picked Signal, a private messaging app similar to WhatsApp, where encryption helps keep conversations private. In fact, versions of the Signal protocol also help protect messages in WhatsApp and Google Messages. Now, researchers have spent decades studying how to make encryption secure. But proving that encryption is secure on paper is one thing. Proving that the actual code follows those same rules is much harder. Because even if the design is perfect, one tiny coding mistake could still create a security hole. So, DeepMind built something called AlphaProof Code to tackle that gap. First, human researchers worked with AI to define exactly what security protections they wanted to prove. Then teams of AI agents powered by Gemini worked together to figure out the mathematical proofs. And here's the crazy part. The agents generated around 6.5 MILLION lines of proof code 😭 But they didn't just trust whatever the AI came up with. Every proof had to pass through Lean, a separate mathematical checker that verifies whether the reasoning is actually valid. So, the AI couldn't just confidently say "yep, this is secure" and move on lol. And they went all the way down to machine code, the actual instructions a processor executes. So, what did they actually prove? Imagine someone manages to steal your current encryption keys. That shouldn't automatically let them go back and read all your older private messages. And if someone temporarily compromises your device, the encryption system has ways to make future conversations secure again once the attacker loses access and fresh keys are exchanged. It also needs to make sure messages really come from the person they're supposed to come from. DeepMind mathematically verified important protections like these in Signal's compiled encryption code, under specific assumptions. And one experiment really caught my attention. They took 2 real security bugs that had already been discovered and fixed in Signal, then deliberately put them back into the code. In both cases, their system mathematically proved that the buggy versions broke the expected security guarantees. That's pretty wild. Instead of just looking for suspicious code, they could actually show when important security protections were broken. Now, this doesn't mean Signal is suddenly impossible to hack. They verified specific parts of its one-to-one encryption, not every possible security issue in the entire app. But think about what happens if we can eventually use this approach for other software. Banks could verify important protections in the systems handling our money. Hospitals could check whether medical devices follow critical safety rules. Car manufacturers could verify software controlling braking and other safety features. Even power grids and aircraft could get stronger guarantees about the code keeping critical systems running. These are all places where one tiny software mistake could have serious consequences. And right now, getting this level of verification is so complicated and expensive that most software never goes through it. If AI can make it much faster and cheaper, we could start checking systems that would've been too difficult or costly to verify before. Imagine catching certain serious mistakes before software ever reaches users, instead of discovering them after something goes wrong. And the timing of this is what makes it even more interesting to me. AI is already getting ridiculously good at writing code. We're moving toward a world where AI agents can build entire apps and complex systems much faster than before. But who's going to check all that code? Because writing software faster doesn't automatically mean we're building safer software. And that's why I find this research so exciting. We've spent years trying to make AI better at writing code. Now we're seeing it help mathematically verify that important parts of that code actually work the way they're supposed to. Of course, DeepMind built on years of earlier verification research, and there's still plenty of work needed before this becomes practical for every kind of software. But doing this on real, widely used cryptographic code in just a month is still pretty insane. Imagine a future where the apps and systems we depend on don't just come with thousands of passing tests, but actual mathematical proofs for their most important protections. We might be heading toward a world where AI doesn't just help us build software faster. It helps us prove we can trust what we've built too. And honestly, that could end up being even more important. What a time to be alive 🔥

holy fucking shit 😳 Claude writes ~90% of Claude Code's code now. so my first thought was... who the hell is reviewing all of it? just read Addy Osmani's breakdown. turns out Anthropic didn't just add AI reviewers. they basically rebuilt how code gets shipped. Claude checks its own work before a PR. other agents hunt for bugs. more agents vote on whether those findings are actually real. CI + security checks can block merges, and humans step in based on risk. but one detail actually cracked me up. an AI author and reviewer once went back and forth 50+ times overnight. 💀 imagine waking up to two agents STILL arguing over the same PR lmao. they actually had to limit review cycles to stop these endless back-and-forths. and the results? more than 2x PRs merged while the share of reverted PRs dropped over 40%. but what I found even more interesting is what happens when bugs still slip through. feature flags, staged rollouts, fast rollbacks. then those incidents become eval cases to test whether the reviewer would catch similar mistakes next time. another thing that stuck with me: nobody on the team has the entire codebase in their head. when they need to understand something, they just ask Claude to explain that specific part. kinda wild when you think about how we've always worked with code. we spent years trying to make developers write code faster. now writing code is becoming the easy part. the real question isn't just "did someone review this code?" anymore. it's what could go wrong, what the checks might miss, when a human actually needs to step in, and what you can safely ship and stand behind. feels like that's where the real engineering is shifting.

Anthropic’s top guy is building a YouTube clone for fun and you’re losing sleep over AI taking your job.