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.
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.
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 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.
The honest version might actually be worse, because sincere people work harder.