Ok, here's what ChatGPT gave me after a little AMA session. Time to test it out.
----
Kai helps build software that protects companies from losing their important information.
Imagine a hospital, bank, or large business whose computers are attacked by criminals. Those criminals might lock up or destroy everything on the computers. Kai works on a system that keeps backup copies of that information so the business can recover.
Right now, he's taking a very large, complicated computer program that was originally built for Windows and making it work on Linux, a different kind of operating system.
It's a little like taking apart a factory that was designed to operate in one country, rebuilding it in another country where the machinery and infrastructure work differently, and making sure it can still produce exactly the same products.
He's not just copying the old program. He's discovering how it works, fixing problems, removing unnecessary complexity, and building tests to make sure the new version can safely handle customers' information.
He's been working on this particular project for the last ten weeks.
And while he uses AI to help him work faster, he still has to understand the software, decide what needs to change, and determine whether the results are trustworthy.
Replying to @gmkurtzer
Because of AI, my lawn is green, my basement DIY projects are done (and I didn't die!), my boss understands what I do more clearly, and I'm thinking it's time to see if AI is up for the real challenge.
Can AI explain how cool it is to "port hundreds of thousands of lines of code to Linux in an Enterprise code base with no regressions" to my wife, with out loosing her 15 seconds in?
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.
Replying to @gmkurtzer @Beckeckeck
Kai Meyer retweeted
The scariest part of this story is that the shell was a fresh session with no env vars loaded.
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
25
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
28
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?
Linus Torvalds Wonders If Linux's AI-Prompted Patch Flood Has Peaked ift.tt/kiFf3lK
2
1
35
Linus Torvalds Wonders If Linux's AI-Prompted Patch Flood Has Peaked ift.tt/kiFf3lK
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.
6
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
16
Kai Meyer retweeted
'The idea that people knew a thing or two in the '70s is strange to a lot of young programmers.' -- Donald Knuth
As the cost of a mistake goes up, so too does the value of the "human in the loop" idea.
It's also true that there is a large range between the cost of "the kerning of that 'i' is off by a pixel" and "some dude died."
The more responsibility you have, the more value you add to the end user. The less responsibility you hold, the more likely your job will be trusted to an AI agent.
If these two things hold any water, then who feel you aren't trusted with responsibility may have very good reason to worry about being replaced with agentic workflows.
My advice is to find a way and a place to be trusted with responsibility.
Which, as it turns out, was solid advice before AI too.
1
2
20
remember that wave of ai psychosis from the beginning of the year?
what lasting software came out of that? the entire discussion was everyone marveling at the process
you gotta learn the lesson that techniques aren't worth discussing until you see impressive output
Kai Meyer retweeted
Better is too subjective and context dependant to make this defensible.
Sometime better is simpler code.
Sometimes better is code delivered faster.
Sometimes better is more performant code.
Sometimes better is more maintainable code.
Sometimes better is code that can be formally verified.
Many times it's a tradeoff.
Kai Meyer retweeted
Remember eMudhra with their Most Secure Private Key Of All Times?
So here's how they managed to do it:
1) They exported a private key from the hardware security module (HSM) into a regular PC (!).
2) They processed this private key with a Python script they wrote (!!).
3) The script had a bug that ruined the key by truncating it to a single byte (!!!).
4) They imported the ruined key back into the HSM and certified it with the root CA.
But that's not the end of it. After the initial "ceremony", the HSM held two keys: the good original and the ruined copy.
A month later, this is what happened:
1) The certificates contained the ruined copy's public key, but the revocation lists (CRLs) were signed with the good original, so their signatures failed to verify.
2) Instead of investigating the problem, eMudhra "fixed" it by signing the CRLs with the ruined key instead.
3) The weak keys went unnoticed until an outside researcher reported them in October 2026.
Good job!
Kai Meyer retweeted
“AI will replace software engineers because it can write all the code.”
Nope.
Several years ago I built software that unlocked more than $10M a year in additional profit for the business.
The code took less than two weeks.
With today’s AI tools, I could probably do it in under a week. Maybe even a day.
But the code wasn’t the hard part.
The hard part took months:
Understanding a messy domain.
Pressure-testing assumptions with experts.
Working through edge cases.
Deciding what not to build.
Making tradeoffs around risk, complexity, and value, then getting stakeholders to sign off on them.
By the time I wrote most of the code, much of the real engineering had already happened.
That’s why “AI can write code, therefore AI can replace engineers” misses the point.
Code is an output of engineering.
AI makes that output faster and cheaper.
But someone still has to understand the problem, challenge the assumptions, make the tradeoffs, and decide what the software should actually do.
That’s the engineering.
Yup. This is how I've been feeling since the beginning.
Lines of code aren't the goal. Number of PRs aren't the goal. Neither of them tell you anything about the future of your software; will people use it, and can you modify it? They can be interesting facts, or part of the picture, but not a goal.
Agents make Goodhart's Law a LOT worse:
"When a measure becomes a target, it ceases to be a good measure."
Agents are incredibly good at gaming metrics. So any organisation that says "we track your number of PR's" is fucked.
Measuring productivity was already impossible. Now it might be actively harmful.
1
53
Kai Meyer retweeted
Agents make Goodhart's Law a LOT worse:
"When a measure becomes a target, it ceases to be a good measure."
Agents are incredibly good at gaming metrics. So any organisation that says "we track your number of PR's" is fucked.
Measuring productivity was already impossible. Now it might be actively harmful.
Kai Meyer retweeted
“No one is looking at compiled binaries” is a lie that we tell ourselves to justify our behavior with AI. No one stopped looking at compiler output.
Low level programmers have readelf, objdump, nm, strip, ldd, elftool, binsider, capa, shiva, and numerous others for examining and debugging the output of compilers.
Java programmers have javap (disassembler), jar, jmd / jdeps, CFR, Fernflower, JD-GUI, and many more.
.NET programmers have ildasm, dotnet-dump, dotnet-gcdump, ILSpy, dotPeek, dnSpy, and many others.
And no discussion is complete without mentioning @mattgodbolt’s excellent Compiler Explorer. Give it high level source code, your compiler settings, and see what assembly code is produced.
Why do we have all these tools if no one looks at the compiled code?
The answer is simple: people still look at compiled code.
The confusion is because we’ve used compilers for more than three decades now. We have a high trust that a given implementation of a loop will create the same, predictable output each time. We don’t both debugging the assembly because it can’t tell us anything we don’t know.
That is, until it does something horribly unexpected. (Compiler bugs are a thing.) Or we need to understand execution performance. Or our output just isn’t making sense and we need to debug why. Could still be our fault. Could be a misunderstanding of the abstraction on our part. But we READ THE CODE to know what it’s doing.
Don’t let anyone make you feel bad for reading code. The source code is the settings for the machine. If you’re not taking the time to understand the code, you don’t really know what the machine is doing. No matter how clear you think your specification is.



























