I’ve been going to DEF CON long enough to remember when it felt like a secret. Not exclusive in the snobby sense, but niche in the way only a gathering of curious misfits, tinkerers, and unapologetic troublemakers could be. It was a place where you could walk into a random hallway and end up in a three-hour conversation about buffer overflows, lockpicking, or some bizarre telephony exploit from the ‘80s.

This year, though, something felt… different. Maybe it’s me. Maybe I’ve grown out of it. Maybe it’s just the sheer mass of people — the lines, the photo ops, the Instagrammable “hacker aesthetic” that makes it feel more like a pop culture event than a gathering of weirdos solving problems no one else cares about.

And then it happened: I saw a picture of Jeff Moss, the founder of DEF CON, doing jello shots with the NSA. Not a metaphor. Not a rumor. Literally jello shots. With the NSA.

The moment was like watching the punk band you loved in high school play a corporate-sponsored halftime show. I stood there, caught between thinking this is hilarious and what the hell happened here?

It’s not that I expect DEF CON to stay frozen in time. Things evolve. Communities grow. People change. But this was a visual that perfectly summed up my uneasy feeling — the line between “us” and “them” has blurred, and maybe it’s gone altogether.

I don’t hate it. I’m not even saying it’s wrong. But I can’t shake the feeling that the DEF CON I fell in love with — messy, raw, niche, and slightly dangerous — isn’t here anymore.

Maybe that’s progress. Or maybe it’s just a sign that the underground doesn’t stay underground forever.

You do not need to take classes on making good experiences anymore.

It’s not about making great software anymore. It’s not about building games people love. It’s about how many damn paywalls you can cram into every corner of your tech stack. Every menu, every feature, every damn pixel has a price tag now. It’s monetization hell and we’re all being dragged through it.

You don’t buy a video game anymore—you subscribe to a “live service” that milks you monthly for skins, DLC, “premium tiers,” or some other garbage they didn’t finish before launch. Enshittification isn’t a side effect—it’s the whole business model now.

The goal isn’t quality. It’s recurring revenue. It’s locking users into a maze of subscriptions, tokens, microtransactions, and artificial limitations that only disappear if you cough up more cash.

It’s not innovation. It’s extraction.

And it’s fucking sickening.

What’s new? Oh, just your usual dose of 1,000+ micro-patches, mysterious scheduler “optimizations,” and a whole bunch of drivers you didn’t know your toaster needed.

The changelog reads like a novel written by a caffeinated robot: fixes for AMD, tweaks for Intel, a gentle pat on the back for ARM, and a completely normal update to BPF that definitely won’t break your debug setup (again).

Should you upgrade? Of course.

Let me be crystal clear: I hate kernel-level anti-cheat.

I’m not talking about a mild dislike, or a passing irritation. I mean deep, primal, disgust. The kind you feel when you realize the thing you paid for—your game, your entertainment, your free time—comes with a side of invasive rootkit-level surveillance masquerading as “protection.”

You call it BattlEye, Vanguard, Xigncode, whatever the hell you want. I call it corporate spyware with a EULA.

It’s MY Computer, Not Yours

Let’s get this straight: no anti-cheat—none—has any damn business installing itself at the kernel level, the most privileged layer of my operating system. You know who else runs code in the kernel?

Rootkits. Malware. Nation-state surveillance tools.

So, no, I don’t want your “proactive protection system” watching every process I launch, analyzing memory usage, intercepting system calls, and God-knows-what-else while I try to enjoy a couple hours of gaming. That’s not anti-cheat. That’s anti-user.

“But It’s Necessary to Stop Cheaters!”

Don’t feed me that line. You mean to tell me the only way to stop some 14-year-old aimbotting in Call of Duty: Disco Warfare 7 is to give you full access to the innermost sanctum of my machine? Are you serious?

There’s a difference between anti-cheat and carte blanche to run black-box software with system-level privileges. If your defense against wallhacks requires administrator rights on MY computer 24/7, your design is broken.

Cheaters are clever, sure. But so are malware authors. You know what they do? Exploit over-privileged software running in the kernel. You’ve just handed them one more juicy target.

I Didn’t Sign Up to Beta Test Your Surveillance System

Let’s talk about transparency. There isn’t any.

What does your anti-cheat actually do? What telemetry does it collect? What heuristics are used to flag me? Does it store that data? Share it? Sell it? Run in the background when I’m not even playing?

You won’t tell me. You’ve locked it up tighter than Fort Knox and buried it in an NDA-laced support email chain.

And don’t even get me started on false positives. I’ve seen legit players banned for running Discord overlays or having a debugger open from their job. Their appeals? Ignored. Labeled cheaters by automated judgment, with no accountability.

The Irony? You Still Don’t Stop Cheaters

And here’s the kicker. You’re still losing.

Despite all this Big Brother garbage, cheaters still infest games. ESPs, ragebots, HWID spoofers—they’re thriving. Know why?

Because you’re fighting a cat-and-mouse game with people who are smarter, faster, and more motivated than your overfunded security team. You’re just screwing over everyone else in the process.

Enough

I don’t want a rootkit with my copy of Rainbow Six. I don’t want a watchdog in the kernel just to enjoy Escape from Tarkov. I don’t want to sacrifice privacy, performance, or basic control over my system for the privilege of not being called a cheater.

You say your mission is to “keep the game clean.”

I say: start by getting out of my goddamn kernel.

I’ve been working on this for awhile. I want to start writing more about Pytorch. One topic that has been taking a lot of my reading time these days is catastrophic forgetting. Lets dive into it. Catastrophic forgetting is a well-documented failure mode in artificial neural networks where previously learned knowledge is rapidly overwritten when a model is trained on new tasks. This phenomenon presents a major obstacle for systems intended to perform continual or lifelong learning. While human learning appears to consolidate past experiences in ways that allow for incremental acquisition of new knowledge (a huge fucking maybe here btw, in fact, a lot of this is a deep maybe), deep learning systems—especially those trained using stochastic gradient descent—lack native mechanisms for preserving older knowledge. In this article, we explore how PyTorch can be used to simulate and mitigate this effect using a controlled experiment involving disjoint classification tasks and a technique called Elastic Weight Consolidation (EWC).

Why do you care? Recently at work, my boss had to explain in detail how my company makes sure that there is no data left if processing nodes are reused. That really got me thinking about this…

We construct a continual learning environment using MNIST by creating two disjoint tasks: one involving classification of digits 0 through 4 and another involving digits 5 through 9. The dataset is filtered using torchvision utilities to extract samples corresponding to each task. A shared multilayer perceptron model is defined in PyTorch using two fully connected hidden layers followed by a single classification head, allowing us to isolate the effects of sequential training on a common representation space. The model is first trained exclusively on Task A using standard cross-entropy loss and Adam optimization. Performance is evaluated on Task A using a held-out test set. Following this, the model is trained on Task B without revisiting Task A, and evaluation is repeated on both tasks.

import torch
import torch.nn as nn
import torch.nn.functional as F
class MLP(nn.Module):
def init(self):
super().init()
self.fc1 = nn.Linear(784, 256)
self.fc2 = nn.Linear(256, 256)def forward(self, x):
    x = x.view(x.size(0), -1)
    x = F.relu(self.fc1(x))
    x = F.relu(self.fc2(x))
    return self.out(x)

As expected, the model exhibits catastrophic forgetting: accuracy on Task A degrades significantly after Task B training, despite the underlying model architecture remaining unchanged. This result validates the conventional understanding that deep networks, when trained naively on non-overlapping tasks, tend to fully overwrite internal representations. To counteract this, we implement Elastic Weight Consolidation, which penalizes updates to parameters deemed important for previously learned tasks.

def compute_fisher(model, dataloader):
model.eval()
fisher = {n: torch.zeros_like(p) for n, p in model.named_parameters() if p.requires_grad}
for x, y in dataloader:
x, y = x.to(device), y.to(device)
model.zero_grad()
out = model(x)
loss = F.cross_entropy(out, y)
loss.backward()
for n, p in model.named_parameters():
if p.grad is not None:
fisher[n] += p.grad.data.pow(2)
for n in fisher:
fisher[n] /= len(dataloader)
return fis

To apply EWC, we compute the Fisher Information Matrix for the model parameters after Task A training. This is done by accumulating the squared gradients of the loss with respect to each parameter, averaged over samples from Task A. The Fisher matrix serves as a proxy for parameter importance—those parameters with large entries are assumed to play a critical role in preserving Task A performance. When training on Task B, an additional term is added to the loss function that penalizes the squared deviation of each parameter from its Task A value, weighted by the corresponding Fisher value. This constrains the optimizer to adjust the model in a way that minimally disrupts the structure needed for the first task.

Empirical evaluation demonstrates that with EWC, the model retains significantly more performance on Task A while still acquiring Task B effectively. Without EWC, Task A accuracy drops from 94 percent to under 50 percent. With EWC, Task A accuracy remains above 88 percent, while Task B accuracy only slightly decreases compared to the unconstrained case. The exact tradeoff can be tuned using the lambda regularization hyperparameter in the EWC loss.

This experiment highlights both the limitations and the flexibility of gradient-based learning in sequential settings. While deep neural networks do not inherently preserve older knowledge, PyTorch provides the low-level control necessary to implement constraint-aware training procedures like EWC. These mechanisms approximate the role of biological consolidation processes observed in the human brain and provide a path forward for building agents that learn continuously over time.

Future directions could include applying generative replay, using dynamic architectures that grow with tasks, or experimenting with online Fisher matrix approximations to scale to longer task sequences. While Elastic Weight Consolidation is only one tool in the broader field of continual learning, it serves as a useful reference implementation for those investigating ways to mitigate the brittleness of static deep learning pipelines.

Why the hell does this matter? beyond classification accuracy and standard benchmarks, the structure of learning itself remains an open frontier—one where tools like PyTorch allow morons and nerds like me to probe and control the dynamics of plasticity and stability in artificial systems.

Look at this. Just look at it. This is what happens when you let people “vibe” their way through coding instead of learning how computers actually work.

What the Hell is Vibe Coding?

Vibe coding is the latest plague infesting our industry—a mindset where developers treat programming like some kind of abstract art form, where “feeling” the code is more important than understanding it. These people don’t optimize, they don’t measure, and they sure as hell don’t care about the consequences of their half-baked, duct-taped-together monstrosities.

Instead of learning how databases work, they just throw more RAM at it. Instead of profiling their garbage code, they scale horizontally until their cloud bill looks like the GDP of a small nation. And when things inevitably explode? They shrug and say, “It worked on my machine!” before hopping onto Twitter to post about how “coding is all about vibes.”

Vibe Coders Are Why Your Startup Burned Through $1M in Cloud Costs

The screenshot above isn’t fake. It’s not exaggerated. It’s the direct result of some “senior engineer” who thought they could just vibe their way through architecture decisions.

• “Why use a cache when we can just query the database 10,000 times per second?”
• “Who needs indexes? Just throw more replicas at it!”
• “Let’s deploy this unoptimized Docker container to Kubernetes because it’s ✨scalable✨!”

And then—surprise!—the bill arrives, and suddenly, the CTO is having a panic attack while the vibe coder is tweeting about how “the cloud is just too expensive, man” instead of admitting they have no idea what they’re doing.

The Cult of Ignorance

Somewhere along the way, programming became less about engineering and more about aesthetic. People treat coding like a personality trait rather than a skill. They’d rather:

• Spend hours tweaking their VS Code theme than learning how their HTTP server actually handles requests.
• Write 17 layers of unnecessary abstraction because “clean code” told them to.
• Deploy serverless functions for every single if-statement because “it’s scalable, bro.”

And the worst part? They’re proud of this. They’ll post their over-engineered, inefficient mess on LinkedIn like it’s something to admire. They’ll call themselves “10x engineers” while their entire app collapses under 50 users because they never bothered to learn what a damn database transaction is.

Real Engineering > Vibes

Here’s a radical idea: Learn how things work before you build them.

The next time you’re about to cargo-cult some garbage architecture you saw on a Medium post, ask yourself: Do I actually understand this? If the answer is no, step away from the keyboard and pick up a damn book.

Because vibes won’t save you when your production database is on fire.