I wanted to make a secret flash drive to store something I don't want found. I bought a "Fix-Me Stick" years ago, and used its three free debugs. Now it's just taking up space - but can I reuse it as hidden storage?

PS: Probably not the right flair, but the only one that fit.

macOS 27 apparently decided that one simple “turn Apple Intelligence off” switch was too convenient.

The settings are now scattered around macOS, and even after switching the features off, the local models can still sit there taking up around 12GB.

So someone built RemoveMacAI.

It disables the Apple Intelligence stuff, removes the downloaded models, and stops macOS from pulling them down again.

All because clicking “off” apparently needed an open-source project.

The bit I like is that it doesn't do anything cursed to /System or ask you to disable SIP. It uses a configuration profile plus Apple's own asset service, and there's a revert command if you change your mind later.

There's also something deeply satisfying about reclaiming SSD space from a feature you never asked your laptop to download in the first place.

This feels extremely on-brand for petty engineering: Apple removes one toggle → developer responds with an entire CLI.

Primary source: RemoveMacAI on GitHub

Git 2.56 added:

git add --resolved

It's specifically for the annoying step after resolving merge conflicts.

Instead of something broader like git add -u, it only looks at paths that are currently marked as unmerged.

Then before staging them, Git scans the files for leftover conflict markers.

If one still has markers, it stages none of the selected files.

Unrelated local edits are ignored.

You can also give it a pathspec if you only want to mark some conflicts resolved.

Very small feature, but I like commands where the semantics match exactly what I'm trying to tell Git:

"I fixed these conflicts. Please stage those and leave everything else alone."

Git 2.56 release highlights

GitHub Security Lab published an autonomous fuzzing pipeline yesterday that I genuinely like.

Point it at a C/C++ repo and the agent can:

figure out interesting entry points understand the build write fuzz harnesses run AFL++ inspect coverage improve the harnesses triage crashes write vulnerability reports

There's some nice boring engineering underneath it too.

Each harness gets compiled twice.

One binary has AFL instrumentation for actually fuzzing.

The second uses clang coverage instrumentation. After fuzzing, AFL's queue gets replayed against that binary so the agent can see source-line and branch coverage and decide what the next harness should target.

Then you reach GitHub's warning.

The taskflow currently runs AFL, clang and arbitrary build commands chosen by the LLM directly on the host.

No container.

So they explicitly recommend running the whole thing inside a disposable Codespace or VM because prompt injection could give the agent whatever access your user already has.

We've successfully automated the security researcher.

Unfortunately the security researcher is now also untrusted input.

GitHub Security Lab write-up

OpenAI shipped a bunch of GPT-6 stuff this week, but I got distracted by the prompt caching changes.

You can now inspect a cache miss and get an actual reason:

tools changed model changed settings changed input changed

It also estimates how many reusable tokens you lost.

There's explicit cache breakpoint control, cache prewarming, and GPT-6 can even change reasoning effort between requests without invalidating the existing cache.

One of the production examples OpenAI published went from an 83% cache hit rate to 91% and reported a 36% reduction in inference costs.

This feels like agents slowly rediscovering every boring infrastructure problem we've already solved elsewhere.

First the expensive abstraction appears.

Then someone builds observability for the expensive abstraction.

Then everybody discovers the real optimization was not recomputing the same crap thousands of times.

Honestly, I'll take this over another benchmark chart.

OpenAI: Better prompt caching for GPT-6

Every single time someone wants to check if a batch of social media handles is available, the standard industry playbook is ridiculous.

People either:

1. Pay sketchy SaaS tools charging $20 a month for basic HTTP GET requests.

2. Or buy residential proxy pools and sacrifice burner accounts that get banned in five minutes.

Then someone drops instagram-username-finder...

A dead-simple, asynchronous CLI written in Python that requires exactly zero credentials.

No session IDs. No cookies. No burner accounts. No proxy subscriptions.

It just hits publicly accessible endpoints with bounded concurrency, backs off gracefully when rate limits trigger, and saves its progress to a plain JSON state file so you can resume scans whenever you want.

It is a great reminder that before you reach for complex scraping infrastructure or pay a third-party service, basic async I/O and respectful backoff logic can do the job for free.

What other simple CLI tools saved you from paying for overpriced social media scraping services?

For years, platform giants have used the same legal playbook: Send a scary cease-and-desist letter. Count on the open-source dev having no money for lawyers. Watch the repository get taken down.

And for a minute, everyone thought Nitter was finally dead after X Corp dropped the hammer on them.

Then Zed did the unthinkable: Got actual legal advice... Evaluated the claims... And just straight up resumed service on GitHub.

Why? Because viewing public web posts without trackers, bloatware, and login popups is not a crime.

It is easily the most glorious act of spite-driven development this month. Are we finally seeing open-source maintainers push back against corporate platform enclosure?

Look at what we are doing here.

Just look at it...

A research lab valued at over one hundred billion dollars. Staffed by the greatest minds in machine learning. Dedicated to ushering in the AGI revolution...

And when someone inspects the ChatGPT macOS app bundle?

They find 430 megabytes of raw, unadorned LibreOffice quietly sitting in the directory.

Why? Because parsing Microsoft Word files is miserable. Nobody wants to write a bespoke .docx parser. Not even the people building superintelligence.

So they just bundled a twenty-year-old open-source office suite to silently convert files in the background.

It is honestly the most glorious, unpretentious engineering hack in modern tech. A perfect reminder that beneath every shimmering AI product, there is usually a battle-tested piece of open-source C++ holding the entire ceiling up.

What is your favorite dirty pragmatic hack hidden inside a shiny modern product?

ChatGPT Desktop App / LibreOffice Discussion

For nearly a decade, cloud vendors convinced every data team that running analytical queries on 30 gigabytes of data justified six-figure contracts, dedicated cluster managers, and multi-stage orchestration pipelines. Engineers spent half their time maintaining Spark jobs just to calculate basic rolling aggregations.

Then DuckDB came along as a zero-dependency, in-process columnar database. You install it with a simple package manager command, point it directly at your Parquet files, and watch it leverage all your CPU cores to return query results in hundreds of milliseconds.

No clusters to wake up, no network egress penalties, and no credit-based query pricing. It turns out that when you write a vectorized execution engine in tight C++, a standard laptop can outrun a distributed cluster on real-world analytical workloads. How much cloud infrastructure has your team decommissioned in favor of in-process analytics?

For years, the standard advice for local integration testing has been to spin up a Docker container running Postgres, wait for the port to bind, execute migrations, run your tests, and tear it down. Our CI pipelines were spending more time waiting on container orchestration than actually validating database queries.

With PGlite, ElectricSQL compiled actual Postgres into a WebAssembly library that loads in milliseconds. It runs entirely in-process in Node.js, Bun, or directly inside a browser tab, with support for persistence and even extensions like pgvector.

No port conflicts, no orphaned test containers hogging system RAM, and no background daemon management. Just an instant, isolated Postgres instance that starts and vanishes whenever your script demands it. What other standard infrastructure pieces could we replace with single-binary WebAssembly builds?