Elon Musk Vs. The Zombie Hordes🧟

Photo by julien Tromeur on Unsplash

Bad data is the enemy of each and every software developer, and you’d expect that Elon Musk would be aware. This is the technical support guy for the government, after all.

Anyone who has ever caused an app crash by entering NULL into a text field knows the pain of bad data. Software developers will know the pain of bad data at scale, and the work it takes to put it right.

So, it’s surprising how public he has been with the news that there are 150-year Americans potentially claiming benefits.

For his part Trump claimed that among benefits claimants that there are:

“millions and millions of people over 100 years old”

It seems like Musk and Trump are right. The database of the Social Security Administration (SSA) has officially turned America into a land of the (undead) free. Or have they?

What Happened So Far

You might remember the Trump administration and its appointed watchdogs at the Department for Government Efficiency (Doge, of course) “uncovered” what they thought was the biggest fraud in human history.

They found over 18.9 million Social Security records belonging to people born in 1920 or earlier, many of whom lacked official death records. Some were listed as being 140 years old. A select few were pushing 150.

That’s right. America has more vampires than Silicon Valley has AI startups.

They’re probably lined up getting benefits as we speak. Oh, the humanity!

Except, of course, the undead aren’t getting benefits. The implication is that this is fraud. 

I’ll tell you what it really is. It’s undead code. It’s a fraudulent record keeping system. It’s bad software engineering practices. Let me explain.

The Default Date That Wouldn’t Die

So what happened? 

It turns out that it’s rather simple. Missing birth dates default to a placeholder value, which in this case, May 20, 1875. 

That’s the convention. I guess because its birth data is missing it’s a safe fallback because there aren’t any real humans still around from 1875 (or at least doing anything other than coding Cobal).

That doesn’t explain everything. In the database death records are not always updated, and there are plenty of records in the database over 100 years old without a date of death (nearly 19 million). So are at least some of these characters born after 1875 and using their vampire abilities to claim disability.

Even if we set aside the vampire jokes, people without death records could theoretically be receiving Social Security payments.

I’m afraid that’s not happening though.

Bad Data

It does seem like a fraudster’s paradise. It feels like billions of dollars funneled to accounts belonging to people who should be six feet under.

Yet it is difficult to collect dates of death. What is well known is the state is bad at collecting data, and terrible at rationalizing it. Even if date of death information is known there is no guarantee it makes it into the department of social security.

This is well known, as The Inspector General of the SSA has been pointing this out since at least 2015, but it’s expensive to clean up bad data (an estimated $5 million effort).

I think it’s not much fun to do, and no software developers are rushing to take on that particular project, especially now if you work for the Government you will be unable to work from home.

And did you know he SSA already checks its records every year? According to a 2023 audit, almost none of these 18.9 million “ghost records” were actually receiving payments. The few that were? Likely real centenarians who just hadn’t been flagged correctly. The US Census reported around 90,000 people aged over 100 in 2023, a far cry from millions reported.

A Real Fraud

What is happening, though, is fraud of a different kind. This fraud is identity theft, but it isn’t about benefits.

Between 2016 and 2020, over $8.5 billion in wages were reported using the Social Security numbers of supposedly 100+ year-olds. One number was even linked to 405 different employers.

No, this isn’t an army of undead retirees working part-time jobs. It’s undocumented workers using fake Social Security Numbers just to get paid. They aren’t even scamming the government as they pay in but never take out. Ironically, that means some of these “fraudulent” numbers actually benefit the system overall.

So Why Isn’t This Fixed?

This is a well-known issue but seems to be continuing into the future. Let’s look at how we got here.

Legacy Systems Are Nightmare fuel

The SSA’s systems date back to the 1930s, and much of their code is ancient by software standards. Some of it is even still in COBOL. Yes, the same language your grandparents might have used. Good luck modernizing that when the skills don’t exist to read the code let alone translate it. Your LLM trained on Reddit won’t be much help either.

Fixing It Costs Money.

The SSA estimated it would take $5 million to clean up the data. For a government department that isn’t affordable and is money the state would pay for federal employees or something of benefit to the people.

Politically nobody gets re-elected for fixing database inconsistencies. That 5 million could be better spent on teachers, or something.

Grandstanding about fraud, though? That plays well in the media.

What Can We Learn as Developers?

This isn’t just an isolated government problem. Developers run into bad defaults, missing data, and system-wide legacy issues all the time. 

Here are a few choice takeaways:

• Your choices will outlive you. That placeholder value you use today may well still be used by someone in fifty years. So choose wisely.

• Legacy systems never seem die. The SSA is still running on decades-old tech. Your company’s old PHP 5 codebase isn’t going anywhere either.

• Data integrity is a long-term investment. Cleaning up bad data isn’t sexy, but ignoring it can lead to multi-million-dollar political scandals. For a similar problem, see tech debt. 

• Fraud detection is harder than it looks. The problem often isn’t scammers, instead it can be bad software design.

• If a politician is ranting about IT issues, assume they don’t understand IT. This should be obvious by now. Oh, this probably applies to your boss too.

Conclusion

The discovery of these zombies was not in any way groundbreaking. Instead, this is a well-known IT problem blown out of proportion. The real fraud wasn’t dead people collecting Social Security checks, it was bad-faith reporting on an ancient database quirk.

And honestly? Any software developer who has dealt with bad data could have told you that.

But people (including Elon Musk) aren’t asking software developers, and the world might just be a better place if they did.

So, the next time you hear someone screaming about millions of undead retirees cashing Social Security checks, just remember: the real zombies are the developers who wrote this system… and the politicians who keep pretending it’s news.