Hacker News Daily: The Stories Everyone's Talking About

An AI just formalized Fermat’s Last Theorem in eleven days, producing thirteen million lines of code to do it. Last week we talked about the AI tipping point, and you know, this feels like another one of those moments where the ground just shifts under our feet. Because this isn't just about solving a hard math problem — it's about AI creating a kind of knowledge that's more verifiable, more trustworthy than what humans can produce alone. It’s a milestone in making mathematics provably, mechanically correct. And it raises this huge question that’s weaving through everything this week: as AI gets superhuman at some tasks, what happens to the humans who used to do them?

What happens to our own skills? Because the answer isn't as simple as you might think. So let's start with the headlines, because that theme is everywhere. The first big one comes from Sylvain Kalache, a former Site Reliability Engineer at LinkedIn. He’s pointing out a paradox that’s starting to bite in operations teams. Companies are rolling out these AI SREs — AI-assisted incident response tools. They can look at an alert, form a hypothesis, check the telemetry, and even fix routine problems all on their own. And they are getting… good. They’re driving down the Mean Time to Resolution for all the boring, everyday fires. So what’s the problem? The problem is the humans.

Kalache’s point, and it’s a sharp one, is that the better these tools get at handling the routine stuff, the less practice human engineers get. When a truly weird, novel, system-breaking incident happens — the kind of thing the AI has never seen before — the humans who are supposed to be the last line of defense are out of practice. Their skills have atrophied. It's a phenomenon the human-factors researcher Lisanne Bainbridge identified all the way back in 1983, writing that automation "reduces operators’ opportunities to practice routine work while leaving them responsible for new and abnormal situations." We’ve known about this for forty years. We just haven’t had to face it in software, not at this scale, until now.

Then you see the same pattern, the same tension, playing out in hardware design. OpenAI showed off a demo of GPT-6 Astra helping design a circuit board in KiCad. And on one level, it’s impressive. The AI has ingested every textbook, every datasheet. It has this deep, encyclopedic knowledge. But according to the folks at EEBench, it’s still a long way from being able to do end-to-end hardware design. Why? Because the real world is messy. AI models are great with the theory, but they struggle with the messy reality of component tolerances, analog signal noise, and all the physical constraints that a human engineer just knows through experience. So again, you have this brilliant tool that can accelerate parts of the process, but it can’t replace the human intuition needed to handle the unpredictable, analog parts of the problem.

It’s great at the declarative, code-based parts of design, but fails when it has to touch the messy physical world. And while we're talking about things AI can't solve, a high-severity remote code execution vulnerability was just found in ALL versions of Chromium. It's CVE-2026-85046, with a severity score of 8.8 out of 10, and it was being actively exploited in the wild. This is your classic, fundamental software infrastructure problem. A sandbox escape. It’s a reminder that for all the incredible advances in AI-powered coding and analysis, we are still building on layers and layers of complex human-written code, and those foundations are still cracking.

No AI is going to magically fix decades of accumulated complexity. It takes vigilant human oversight, patching, and a deep, systemic understanding to keep the lights on. It’s the kind of complex failure that, ironically, our AI-assisted SREs might not be trained to handle. Finally, a couple of quick hits on infrastructure and privacy, which is a recurring conversation on Hacker News. A new service called Statichost.eu is in private beta. It’s a hundred percent European static site hosting platform — git-based deployment, free SSL, the works. The whole pitch is infrastructure sovereignty. Your data stays in Europe, under GDPR, on a privacy-focused CDN. It’s already being used by organizations like JUnit.

This comes right as Mullvad, the VPN provider, announced it’s shutting down its public encrypted DNS service. Instead, they’re going to sponsor Quad9, which they call the "undisputed leader" in the field. It sparked this whole debate about centralization versus specialization. Is it better to have many small, privacy-focused providers, or to consolidate behind one big, well-funded foundation like Quad9 that can better withstand legal and political pressure? There’s no easy answer, but the Statichost launch shows that the desire for independent, sovereign infrastructure is definitely not going away. It’s a direct response to the feeling that too much of our core infrastructure is controlled by too few players.

So what does it all add up to? You’ve got AI performing superhuman feats of logic, while at the same time making our human engineers more brittle. You’ve got AI acing the textbook problems in hardware design, but failing at the messy realities. And you have these foundational security and infrastructure problems that require a kind of deep, hands-on expertise that these new tools might actually be eroding. The big story here isn't just that AI is getting powerful. It's about the new kinds of fragility we're creating in the process. Okay, let's go deep on that fragility. Let’s start with the SREs, because this is the most immediate, practical example of this paradox.

Sylvain Kalache is basically ringing an alarm bell that most of the industry is ignoring. Everyone is racing to automate incident response because, on paper, it looks like a pure win. You reduce pager fatigue, you fix things faster, you lower your MTTR. The metrics look great. Your VPs are happy. But you’re creating a hidden debt. Here's the pattern twin, the place where we've seen this before: commercial aviation. For decades, airplanes have been getting more and more automated. The autopilot and flight management systems can handle takeoff, cruise, and landing in most conditions. So what do the pilots do? They monitor the systems. And for ninety-nine-point-nine percent of flights, that’s all they do.

But they are still in that seat, and legally required to be, for the zero-point-one percent of the time when things go catastrophically wrong. When a flock of birds takes out both engines over the Hudson River, the autopilot just gives up. It disengages and says, "Your problem now." And in that moment, you need a Sully Sullenberger, a pilot with thousands of hours of hands-on stick-and-rudder time, whose muscle memory is so ingrained that he can fly an unpowered 70-ton glider into a river without killing everyone. The aviation industry understood this danger decades ago. They saw the "automation paradox" that Lisanne Bainbridge wrote about. Their solution?

Simulators. Every six months, every single commercial airline pilot in the world has to go into a full-motion simulator and practice the things that almost never happen. Engine failures on takeoff. Cabin depressurization. Total electrical failure. They practice these rare, complex emergencies over and over again, so that their skills don't atrophy. They are actively, deliberately training for the exceptions, because the automation handles the rules. Now look back at software. We’re doing the exact opposite. We're building AIs to handle the routine incidents, which is fine. But what's our simulator? What’s our plan for keeping our engineers' skills sharp for the day the AI says, "I don't know what this is, it's your problem now"?

We don't have one. We have "chaos engineering," which is great, but it's not the same as systematic, mandatory practice on novel failure modes. We’re deskilling our first responders and hoping for the best. Kalache’s point is that the tech industry needs to learn from aviation, and FAST. We need to start building incident simulators. We need to treat SRE proficiency as a perishable skill that needs constant practice, especially as our day-to-day tools get smarter. Otherwise, the next time a truly novel, cascading failure hits a major system, our response time won't be lower. It'll be catastrophically higher, because the humans in the loop will have forgotten how to fly the plane.

Now, let’s flip to the other side of this coin. Because at the exact same moment we’re worrying about AI making us dumber, it's also demonstrating a kind of intelligence that is breathtakingly smart. Anthropic’s AI, Claude, just produced a formal proof of Fermat's Last Theorem. To really get what that means, you have to understand what a "formal proof" is. A traditional mathematical proof is written in human language, maybe with some symbols. It’s a logical argument meant to convince other human mathematicians. But it can have subtle gaps or unstated assumptions. A formal proof is different. It's a proof written in a special, machine-readable language — in this case, a language called Lean.

Every single logical step, no matter how tiny, has to be explicitly stated and derived from the fundamental axioms of mathematics. It is ridiculously, painfully rigorous. The result is a proof that a computer can check from top to bottom and verify as one hundred percent correct. There's no room for ambiguity or hand-waving. And the scale of this is just… mind-boggling. The AI didn't just solve one equation. It generated 13 MILLION lines of Lean code. It created and proved 29,500 intermediate theorems along the way. It took an 11-day, non-stop effort from the AI to build this entire logical edifice from the ground up. Kevin Buzzard, a mathematician at Imperial College London who's a huge proponent of this stuff, called it an "extraordinary autoformalization achievement." He confirmed that the proof is multi-layered and robust enough for other mathematicians to now build upon.

So where have we seen this before? Think about the transition from oral tradition to written history. For millennia, history was what one person remembered and told another. It was fallible, it drifted, it was subject to interpretation. The invention of writing allowed for a more stable, verifiable record. What we're seeing here is a similar shift for mathematics. We're moving from proofs that rely on the consensus of a small group of human experts to proofs that are mechanically verifiable and permanently trustworthy. The AI isn't just a calculator; it's acting as a scribe, a logician, and a builder all at once, creating an artifact of pure reason at a scale no human ever could.

But here’s where the analogy with the SREs comes back in. This achievement is incredible, but it's also narrow. The AI was given a very specific, well-defined problem within a closed logical system. It’s the ultimate "textbook" problem. It's not dealing with the messy, unpredictable real world of analog circuits or cascading production failures. It’s a demonstration of pure, brittle genius. It can prove one of the hardest theorems in history, but it can't tell you why your website is slow. So the two stories aren't a contradiction. They're two sides of the exact same coin. We're building tools of immense power and precision, tools that can exceed human capabilities in specific, formal domains.

But we're also discovering that the more we rely on them for routine tasks, the more we risk losing the broad, intuitive, hands-on expertise needed to manage the messy reality that exists outside those formal domains. The AI can prove the theorem, but it can't handle the bird strike. The challenge for us isn't to stop the AI. It's to figure out how to use its genius without becoming fragile ourselves. It means building the simulators. It means valuing and practicing the hands-on skills. It means understanding that the most important work a human can do is often the messy, unpredictable stuff that can’t be automated. So this week sets up a fundamental choice.

We're clearly at an inflection point where the nature of technical work is changing, and changing fast. On one path, we chase the short-term productivity gains. We automate away the routine work, we let the AI handle the incidents, and we watch the metrics go up and to the right. And for a while, it will work. Until it doesn't. Until we hit that one-in-a-million failure, that black swan event, and we realize the humans we're counting on haven't actually flown the plane in years. That's the path of hidden fragility. The other path is harder. It's more expensive. It acknowledges that human expertise is a perishable asset that requires constant investment. It means taking the lesson from the pilots.

It means building the simulators, running the drills, and deliberately carving out time for engineers to practice the hard stuff, even if the AI is handling the easy stuff. It means treating human factors not as a soft science, but as a critical component of system reliability. It's about designing a partnership with these new tools, not an abdication to them. The formalization of Fermat's Last Theorem shows us the incredible heights AI can reach in a world of pure logic. The Chromium vulnerability and the struggles in analog hardware design show us how messy the real world remains. The core task of the next decade of engineering won't be just building better AI.

It will be building better humans to work alongside it.