Kai Meyer (@KaiMeyer) header
Kai Meyer (@KaiMeyer) profile picture

Father C/C++ Software Engineer in Data Protection Linux Gamer Dallas "This is our year" Cowboys fan

Joined August 2026
Photo by Kai Meyer (@KaiMeyer)Photo by Kai Meyer (@KaiMeyer)Photo by Kai Meyer (@KaiMeyer)Photo by Kai Meyer (@KaiMeyer)Photo by Kai Meyer (@KaiMeyer)Photo by Kai Meyer (@KaiMeyer)Photo by Kai Meyer (@KaiMeyer)Photo by Kai Meyer (@KaiMeyer)Photo by Kai Meyer (@KaiMeyer)Photo by Kai Meyer (@KaiMeyer)
Kai Meyer retweeted
Without IT professionals, the world would be in a much worse place. So much of our critical systems rest on the backs of dedicated, hard working and selfless people. IT admins, network engineers, help desk, DBAs, and so many other roles help keep this duct-taped ship afloat. IT pros are my heros.
66
127
17
1,027
38,072
Linux kernel developers create guidelines targeting irresponsible developers using AI. There, I fixed your headline.
Linux kernel developers want to block AI-generated junk patches. SUSE developer Qu Wenruo proposed an AGENTS.md file with rules for AI agents and newcomers submitting patches to Linux’s Btrfs filesystem. He says some contributors are “doing more harm than help,” sending low-value fixes buried in long explanations and useless test details. His message to AI agents is blunt. “Stop being stupid.” The proposed rules call for shorter explanations, useful comments, and clearer bug descriptions. The file is still open for review. Source: lore.kernel.org/lkml/df1c1fa…
24
This is a pair of strawmen personified. Both sides of this rhetoric exchange are cringe worthy. The soft condescension from one side and the unreasonable anger from the other side. This doesn't help anyone. It serves only to continue to drive the wedge, not heal broke relationships. Here's the reality. Language models are amazing banks of encoded knowledge. Context windows are fickle. Too small and you get hallucinations. Too big and you drown important data in the menutia. Tools add determinism to the output. Selecting tools is a skill, one that still relies heavily on the user. There doesn't seem to be a limit to the tools we can write and select from, and this is the sort of unbounded growth that's good for tech. Harnesses use the LLM to help select the tools, loop the context window through tools, and produce extraordinary results. AI is a tool, it requires skill to learn, and most people are willing to learn new skills in order to make a buck. Volume of code alone is not a good metric for quality or productivity. Code with out an owner is a recipe for disaster. The volume of code produced with out ownership is experiencing a meteoric rise. CVEs are a good thing, and more CVEs means more of a good thing. A careful study of the most recent CVE run should increase your trust in "hand written code" not decrease it. The contortions required to exploit many of the recent CVEs are virtually impossible, even for dedicated AI. Remember PHP2Shell? Still zero confirmed cases of an exploit in the wild, despite having a working proof of concept. Drive by AI bug reports are worse than unowned code. Come on people, at least offer a fix. And none of that requires embodying either of the totems in this video.
For developers (and anyone really) who feels like AI is taking away their identity. It's the end of something, that's true, but it's also the start of something else.
26
Nothing about AI coding is new. I've inherited a ton of source code over the years, code I didn't write that I'm supposed to extend, update, modernize, add Linux support, and answer the phone when there's a bug. The only difference with agentic coding is that I'm the first one to look at this novel code. It hasn't been in production for 10 year. When I read it, it's just more of the same. Weird things I wouldn't have done, amazing things I wouldn't have done, working things I wouldn't have done, and every now and then it's exactly what I would have done. That last one scares me more than it should. But it's all the same in the end. Code I need to keep modifying and support, even though I didn't type it out.
20
Everyone seems to have forgotten that code is a liability, not an asset. That means that producing thousands of lines of code you didn’t read isn’t something to celebrate. It’s something to worry about! Every line of code needs to be tested, secured, and maintained. Even the ones that create no value for customers and therefore no value to the business. That’s why every line of code is a liability. And producing more liabilities isn’t good engineering or good business. Good engineering isn't about producing more code. It's about solving problems with the least amount of code. The asset is the solution, not the code.
155
278
39
2,123
61,212
Kai Meyer retweeted
Honestly I’m tired of this AI discovered RCE bullshit. It creates so much chaos inside of companies that have no idea how to deal with this. Anyone that publishes an exploit that can’t be widely exploited and doesn’t disclose this - I’m down for total public shaming of the individuals and companies that push this narrative. I’m not dismissing the criticality of latching on these - however it doesn’t require IR, all hands on deck, must patch tomorrow - which is probably why we see the mass outages we are experiencing. It’s damaging our industry. We need to fight back on this and go after those that hype this up for ego and marketing. POC || GTFO Join me.
152
341
43
2,209
111,943
In today's adventure of "Can Claude Code It?" I caught Claude writing "bad" code. This is why I avoid letting Claude author commits when it thinks it's ready, so I can "read the code". Claude wrote a Catch2 statement for a function that returns std::error_code like this: REQUIRE(!fn(arg)); This runs counter to the AI narrative that "Code is memory" because every other test in the repo (there's about 20,000 lines of it) sets the precedent that it should have been "REQUIRE_FALSE(fn(arg));". This is "bad" code, and here's why. When using the boolean operator for an error_code, you get 0 or 1, pass or fail. So when Claude ran against a fixture that caused the function to return an error, it realized that it didn't have enough information to debug the failure. So it expanded the statement into 3. auto ec = fn(arg); INFO("fn: err: " << ec.value() ", message: " << ec.message()); REQUIRE(!ec); In this case "CAPTURE" would have been the right macro, which only emits on error, where "INFO" emits every time it executes. When I read the code, I pointed out that "REQUIRE_FALSE(fn(arg));" is the right statement, it thanked me and l "fixed" it. This is how many of my coding sessions with Claude goes. This one happened to be easy to describe. Still, writing software with Claude is much better than with out. It's just not a silver bullet. Please read the code.
1
1
53
Kai Meyer retweeted
Unpopular opinion: The people who aren't intimidated by the "AI will destroy software engineering jobs" hype and continue to learn the fundamentals of computer science and software engineering will be the big winners in the next 2-5 years. Even with all the advances in AI, we will need more software engineers, including junior engineers, as the software market expands.
Students are fleeing computer science. US enrollment in computer and information science programs fell more than 12% for undergraduates and more than 10% for graduate students this fall, per preliminary data from the National Student Clearinghouse. Over two years, undergraduate enrollment is down 18.4% and graduate enrollment 27.1%, reversing years of growth as AI cuts into entry-level coding jobs.
128
121
23
1,989
88,250
Kai Meyer retweeted
10
45
6
247
26,328
Checks out.
AI models are getting really good at naming things. I created a little CLI to diagnose system slowdowns, and it named it 𝚑𝚘𝚐 🐖, which I love. Given they're already good at cache invalidation, maybe computer science's hardest problems are solved after all 😂
12
The scariest part of this story is that the shell was a fresh session with no env vars loaded.
13
2
111
7,535
In today's adventure of "Can Claude Code It?" I found Claude writing code that relied on untracked files that were in a folder that was in ".gitignore". It's ok, we've all done it. That's why I knew what I was looking at when I 'read the code'. It's in my context window.
1
2
31
After 20 years on Red Hat and Ubuntu, seeing macOS devs discover how fast Linux feels without desktop bloat never gets old. Whether you go full Omarchy or just spend an hour tuning Hyprland on an LTS base, LLMs have officially killed the config tax. Welcome to the team! We have cookie( blocker)s!
I am flying dude, this is truly the greatest OS I have ever used, it's been on my desk for 6 months now but I am a laptop guy at heart. Dell-xps + Omarchy is state of the art rn. I am done with MacOS, done with the permission slop. Malleable computer.
1
1
33
SecOctobrAgeddon is in the past and we need to learn the right lessons. Are we discovering a security disaster that we've been building for decades? Or are we discovering just how secure our software actually is?
2
1
37
Don't judge a book by it's cover. Be safe out there.
I can't find a single Rust Application that qualifies as "Safe Rust". Tested the top 1000 rust crate dependencies, only 182 of them were free of explicit unsafe declarations. The cve-rs crate uses #![deny(unsafe_code)] everywhere & still exploits memory vulnerabilities just fine. I think most of rust rewrites reduce memory leaks mainly because you're refactoring the entie codebase with a smarter agent using a better linter/lsp and not because of the language itself.
8
It bears repeating. We're better together.
Do we still need manual code reviews? Coding agents can write code fast. So the next question is: can they review code fast, too? A team at Microsoft Research tested ten models on CRBugBench, a new benchmark of 1,800 real bugs (1,000 from 98 GitHub projects, 800 from one company's code). Their best performer (Claude Opus 5, via Copilot CLI) found 71.9% of real bugs, at about ten minutes and $3 each. Five months earlier, the best model was at 47.7%. Humans, for comparison, find about 50% of bugs before a PR gets merged. When we combine humans and AI, they find 82.1%, as AI is better at spotting high-severity and reliability bugs while humans are better at detecting maintainability issues. Bigger diffs are harder for AI to review, which is expected. Each standard deviation increase in diff size corresponded to about 40% lower odds of finding the bug. Bug-fix PRs are also harder to review than feature PRs (half the odds). Proprietary code was harder to review than open-source code (up to 25.5% fewer bugs found). Fewer of its bugs were visible in the diff (22.8%, compared to 46.1% on GitHub). Agents opened the relevant file 95.6% of the time, but identified the bug only 56.2% of the time. In one PR (fixing a Selenium bug), every model accepted a buggy condition because the code comment and the PR description said it was correct. 𝗠𝘆 𝘁𝗮𝗸𝗲𝗮𝘄𝗮𝘆𝘀 The 'lights-off factory' scenario (AI reviews AI-written code) is viable, but probably only for small, well-scoped PRs. Otherwise, treat AI as one of your reviewers, and keep a human in the loop. If you want to use AI code review at your org, my recommendations are to: - Experiment with routing different PRs to different reviewers (in CRBugBench, a smaller model reached 78% of Opus 5's score at 21% of the cost) - Ask for more, ranked suggestions (outperformed multi-agent setups that cost several times more) - Provide more repo context - Keep a human reviewing for maintainability concerns and verifying the PR description
17
'The idea that people knew a thing or two in the '70s is strange to a lot of young programmers.' -- Donald Knuth
1
23
1
114
8,215