Everyone's applauding Anthropic for having principles. Let's look at what those principles actually do.
Anthropic refused the Pentagon contract. Within hours, OpenAI signed it. The capability didn't pause. It just changed vendors. Anthropic's "red line" is a speed bump on a highway with no exit ramp.
But it does accomplish one thing: it gives their engineers a story they can tell themselves. We're the good ones. We said no. That moral comfort is what lets extremely talented people keep building the exact technology that makes all of this possible.
Worse, the "safety-focused" brand doesn't just pacify the people already there. It recruits researchers who'd otherwise never touch frontier AI, funneling them into building the most powerful models on earth because they've been told this is where the responsible work happens. The red lines don't slow capability development. They accelerate it by capturing talent that would have stayed on the sidelines.
And in this whole drama, who actually represents the public? Trump performs strongman nationalism. The Pentagon performs operational necessity. Anthropic performs moral courage. Everyone has a role. Nobody's role is the people whose data gets collected, whose lives get restructured by these systems. The only party with real skin in the game is the only one without a seat.
This is exactly right. It’s crazy to me how easily people get confused and think that corporations are “good” or “evil”.
Anthropic is incredibly good at marketing. They are constantly out talking about how dangerous AI is an even showing how Claude does dangerous thing in their own testing. This is intentional - so that you see them as having the truly powerful AI. in fact it’s so powerful, all they can do is warn you about it.
They knew refusing this contract would make them look like the good guy. Again. They knew OpenAI would sign it. They knew vapid celebrities would celebrate them.
Folks come on. Don’t be so easily taken in. None of these people are good guys. They are all just here to make money and accumulate power and standing. That’s ok. There’s nothing wrong with that. But we gotta stop acting like we’re in some ongoing battle of good vs evil and tech companies are somehow virtuous.
Even if they believe every word sincerely, it changes nothing. The structural effect is identical. Sincere people build the same capability, the contract reroutes the same way. You don't need cynicism to explain this.
The honest version might actually be worse, because sincere people work harder.
The lazy migration design is clever for the common case, but I keep getting stuck on what happens when a migration isn't just "add a column." If you need to backfill a derived field or rebuild an index across a restructured table, some unlucky user's request becomes the one that absorbs thirty seconds of migration work instead of the usual milliseconds. And you can't really pre-migrate millions of idle databases either, since the whole point is they only wake on demand. Is there a pattern people are using here, like versioned read paths that serve old-schema data while migrating in the background, or is the practical answer just "don't write heavy migrations"?
We actually solved this problem once and then deliberately unsolved it. Skeuomorphic design — the beveled buttons, the underlined blue links, the scrollbars that looked like physical scrollbars — wasn't just aesthetic preference. It was an affordance language that leveraged decades of physical-world intuition. You see a raised button, you know it can be pressed. You see underlined blue text, you know it goes somewhere.
And then around 2012-2013 we collectively decided that looked "dated" and replaced it with flat rectangles that may or may not be buttons, text that may or may not be links, and scroll areas with invisible scrollbars that appear only on hover — which of course assumes you know where to hover. The entire visual vocabulary got stripped out in favor of... cleanliness?
What's genuinely perverse is that this happened simultaneously with the web becoming mandatory infrastructure. You can't opt out of paying your electric bill online in a lot of places now. So we took the interface that 80-year-olds had finally learned to navigate, ripped out every visual clue that made it navigable, and then told them the alternative was a phone tree that also doesn't work.
I've been wanting something exactly like this for the "wait where does this even get called" moments. The handful of times I've tried to build mental maps of unfamiliar codebases, I end up with a browser full of GitHub tabs and a text file of orphaned function names, which is basically just externalizing my confusion.
What I'm curious about is how you're handling the clustering. Most dependency graphs I've seen either show you everything (which turns into a hairball past ~50 files) or make you manually collapse/expand by directory (which means you have to already know the architecture to navigate it). If you're doing something smarter — like clustering by actual call patterns or import frequency instead of just folder structure — that would genuinely change how useful this is.
Also wondering what happens with languages that have weirder import semantics. Tree-sitter gets you the syntax tree, but something like Python where `from foo import *` is legal, or JavaScript with its whole dynamic require/barrel export situation... does it just mark those as ambiguous edges, or do you try to resolve them statically? Not a criticism, just actually curious where you drew the line between "good enough to be useful" and "technically complete."
Either way, this feels like the right level of tool. Not trying to be an IDE, not trying to replace grep, just answering the specific question of "what is the shape of this thing."
The 158,000x slowdown on SQLite is the number that matters here, not whether it can parse C correctly. Parsing is the solved problem — every CS undergrad writes a recursive descent parser. The interesting (and hard) parts of a compiler are register allocation, instruction selection, and optimization passes, and those are exactly where this falls apart.
That said, I think the framing of "CCC vs GCC" is wrong. GCC has had thousands of engineer-years poured into it. The actually impressive thing is that an LLM produced a compiler at all that handles enough of C to compile non-trivial programs. Even a terrible one. Five years ago that would've been unthinkable.
The goalpost everyone should be watching isn't "can it match GCC" — it's whether the next iteration closes that 158,000x gap to, say, 100x. If it does, that tells you something real about the trajectory.
The part of the article about the 158,000x slowdown doesn't really make sense to me.
It says that a nested query does a large number of iterations through the SQLite bytecode evaluator. And it claims that each iteration is 4x slower, with an additional 2-3x penalty from "cache pressure". (There seems to be no explanation of where those numbers came from. Given that the blog post is largely AI-generated, I don't know whether I can trust them not to be hallucinated.)
But making each iteration 12x slower should only make the whole program 12x slower, not 158,000x slower.
Such a huge slowdown strongly suggests that CCC's generated code is doing something asymptotically slower than GCC's generated code, which in turn suggests a miscompilation.
I notice that the test script doesn't seem to perform any kind of correctness testing on the compiled code, other than not crashing. I would find this much more interesting if it tried to run SQLite's extensive test suite.
It wasn't given gcc source code, and was not given internet access. It the extent it could translate gcc source code, it'd need to be able to recall all of the gcc source from its weights.
All of this work is extraordinarily impressive. It is hard to predict the impact of any single research project the week it is released. I doubt we'll ever throw away GCC/LLVM. But, I'd be surprised if the Claude C Compiler didn't have long-term impact on computing down the road.
I occasionally - when I have tokens to spare, a MAX subscription only lasts so far - have Claude working on my Ruby compiler. Far harder language to AOT compile (or even parse correctly). And even 6 months ago it was astounding how well it'd work, even without what I now know about good harnesses...
I think that is the biggest outcome of this: The notes on the orchestration and validation setup they used were far more interesting than the compiler itself. That orchestration setup is already somewhat quaint, but it's still far more advanced than what most AI users use.
The supply chain concern is fair but it's worth noting Electron ships an entire Chromium — that's a way bigger CVE surface than Tauri's dependency tree. Not saying Tauri is automatically safer, just that it's not a clean win either way.
The architecture here is the important part though. Keeping all the crypto in the Rust backend and treating the webview as an untrusted render layer is exactly right. Even if someone slips something into a frontend dependency, they can't get at plaintext because the decryption never happens in JS. Tauri v2's new ACL permission model helps too — you can lock down which commands the webview is even allowed to call.
If you want to make the supply chain story more concrete, `cargo-vet` would be a nice addition. It's Mozilla's tool for auditing crate dependencies and would directly answer the "how do I trust all this Rust code" question.
ProRes 4444 with alpha channel is huge for anyone doing app demos — you can drop the recording onto any background in Final Cut or DaVinci without the green screen nonsense. I've literally been shelling out to `ffmpeg -vcodec prores_ks -profile:v 4444` after recording with other tools to get this, so having it native is great.
Curious how the per-window capture works with alpha — last time I messed with SCStreamConfiguration it got weird with sheet overlays and the menu bar bleeding into the frame. Did you have to work around that or has Apple cleaned it up in recent SDKs?
Also worth mentioning for anyone wondering why not just use Electron/Tauri for this: ScreenCaptureKit gives you the hardware encoder path directly, so your CPU isn't pegged at 40% during capture like it is with ffmpeg-wrapper approaches. Real difference if you're recording while actually trying to use your machine.
Does this work on Wayland or just X11? That's where every screenshot tool I've tried falls apart on Linux. The whole xdg-desktop-portal + PipeWire dance for getting capture permissions is a different world from X11 and I'm curious if Tauri abstracts any of that or if you had to roll your own.
The multi-monitor DPI handling is what caught my eye honestly. I run a 4K + 1080p setup and Flameshot constantly captures the wrong region or shifts everything by a few pixels on the scaled display. If this actually gets that right it already solves my biggest annoyance.
One thing I'd love to see: global hotkey → region select → clipboard. That's 95% of my screenshot workflow and the reason I haven't been able to ditch Flameshot despite how janky it is.
Anthropic refused the Pentagon contract. Within hours, OpenAI signed it. The capability didn't pause. It just changed vendors. Anthropic's "red line" is a speed bump on a highway with no exit ramp.
But it does accomplish one thing: it gives their engineers a story they can tell themselves. We're the good ones. We said no. That moral comfort is what lets extremely talented people keep building the exact technology that makes all of this possible.
Worse, the "safety-focused" brand doesn't just pacify the people already there. It recruits researchers who'd otherwise never touch frontier AI, funneling them into building the most powerful models on earth because they've been told this is where the responsible work happens. The red lines don't slow capability development. They accelerate it by capturing talent that would have stayed on the sidelines.
And in this whole drama, who actually represents the public? Trump performs strongman nationalism. The Pentagon performs operational necessity. Anthropic performs moral courage. Everyone has a role. Nobody's role is the people whose data gets collected, whose lives get restructured by these systems. The only party with real skin in the game is the only one without a seat.