yearolinuxdsktp

I disagree it’s impossible to solve. Huge C++ projects don’t have continuously growing build directories and can still compile incrementally correctly.

Manufacturers laugh in the face of right to repair laws. They have no teeth.

So you can buy repair manual access for 1-3 days or on a subscription. You don’t get car software updates. You don’t get the diagnostic interface documentation. It’s a joke.

Not really, not even “you need a dash kit” situation, because HVAC controls and other essentials are now integrated with the radio.

Thankfully for some, Subaru refused to comply with right to repair laws in some American states without disabling its Starlink/MySubaru system. So you get auto-opted out in those states.

It’s insane. 45 minutes to build debug from scratch. Linking is super slow even in debug and that’s without LTO.

Incremental compilation is not cleaned up. Older deps pile up and don’t get cleaned.

Run out of disk space? Oh it’s just the 200+ GB codex-rs target folder.

Forget about doing worktrees.

Rust has a lot of work to do.

It is ridiculous. It took months for 3.1 Pro to become available in an enterprise account.

The excuse was it was still “in preview” and the enterprise didn’t opt in to the preview channel.

With Google, it’s either in beta or deprecated.

Osquery https://codeberg.org/DAWO/DAWO-Core/issues/92 via https://sextantfleet.org/ looks to be what they are using (run by main contributor)… all “policy” is via NixOS… how tenable that will be we will see, but the landing page is heavy on compliance with audits

Here's a palatable, clear version:

https://pdfhost.io/v/2CVhPGy9Kw_CLEAR_Function_Hooks_Core_Ar...

Maybe you have to set reasoning effort to low. 3.8 27B on x-high (default) reasons forever on anything complex. I asked it to write down the answer plan so far leaving open questions as open and it wrote the plan twice in reasoning (and more times partially) while it dilly-dallied about open questions before realizing “ok the user just asked to leave questions open.” That was a Q6o quant with unquantized KV cache.

Codex has an “Approve for me” mode (“Guardian” internally) that does the same now.

“Autoplay” and YouTube case in point:

- Autoplay transitioned to a per-device setting… suddenly default-on on every new device you log in to.

- Watching a video with computer-to-TV account connection? Automatic “TV queue,” a concept absent from the TV app, with incomprehensible behavior for how it’s used, so now videos are auto-played anyway.

- Watching a video from a playlist? Autoplay cannot be turned off.

Is it simply bad/absent product management and product design? Or is it actively user-hostile decisions meant to prop up view numbers and continue to have the users hooked on YouTube?

Pray tell, what output style does the job?

The writing style is extremely frustrating/maddening!

I’ve tried so many things and I have to beat Opus 5/Fable 5 over their head every time. With Opus 5, the failure to actually improve the writing is borderline comical. Both models have been building up tomes of memories on top of my core rules, all to be ignored.

Nothing sticks mid-writing! The only lever is to ask to revise after the fact, a particularly futile proposition for anything non-trivial with Opus 5.

In contrast, GPT 5.6 Sol Max absolutely obeys my edicts to write well. I selected the concise writing style and its default writing is really not bad, but tighten it up with a standing AGENTS.md order and it obeys.

The downside is that even at Max, it’s not as good as Fable or Opus 5 xhigh at writing code. Larger work and the 256k context’s forced compactions cause it to lose track/fidelity of critical details. Review passes are essential.

Another reason I’m considering leaving Anthropic are the sporadic refusals… Fable printed a Markdown body with a hex dump to inspect for trailing white space and line endings, boom, denied due to `reasoning_extraction`. Had to tell Fable to never do hex dumps. Asked it a few times “what do you think is typically done for this?”, got another `reasoning_extraction` error. It forces you to lose a whole turn of work when you have to press Esc/Esc to “retry” the last prompt… except if that prompt was mid-turn, you’re losing your entire turn.

The recent BashFirst experiment is hella nuts, where it prefers writing bash over Edit/Write tools in auto mode. WTF Anthropic?

I pity those stuck with Claude in an enterprise/work setting.

Fascinating! I am glad you’re getting good results with that. Maintaining abstractions is critical and it’s very frustrating when the LLM ignores them.

The emdash allergy is shortcut sheep mindset. Emdashes are commonly accepted and orthographically correct punctuation in many languages.

Also it looks like English might not be the author’s first language—might not lead to the best training corpus.

I disagree with the naysayers. The README was scannable and sectioned so I could read what I wanted. But some things I wish were clearer, and I’m not sure they would be if you wrote it by hand.

Don’t waste your time rewriting it by hand just because keyboard warriors are up in arms on HN.

The material feedback here reflects the questions who might be from someone who’s been running local LLMs, so ask the LLM to update it with that in mind.

Another poster pointed out it’s not clear what the quantization is. There’s that one paragraph but it’s confusing. What I want to know right away is: are you running the unquantized model or is it quantized? If so, how much? Use terms like Q3 or Q4 or 4-bit or 8-bit. Explain why it’s not practical to quantize less. How much precision loss do you think there is at the quantization selected? What if I had 128GB RAM and wanted to have better precision and not higher token speed—would it be a good idea to choose 4-bit instead of 3-bit for some of these layers?

If you’re using the pi.dev harness, I found this tool to be quite good as a compaction alternative: https://pi.dev/packages/pi-blackhole — it keeps a memory so every prior conversation piece is recallable, not lost.

Try running your rule files through an LLM for optimization. 60k-80k tokens is massive.

Funnily enough, most anti-slop skills I found are both way too verbose and miss some common slop constructs.

I also reduced many rules from “When doing X, don’t do Y, but do Z.” Instead, the rule is “When doing X, do Z.” Fewer tokens and often works better.

I had one critical rule I was maintaining about searching the codebase using a structural index/graph and not grep. Every time the agent missed it, I asked it how to improve the rules. Eventually, I asked the AI to review that rule file and it rewrote it to be 30% smaller, but, crucially, structured to be more understandable by the LLM.

Another helpful thing was to ask AI to review my rules for things it can load on-demand when it works in that area.

I think that the gallup poll is flawed because it does not explain what daylight saving versus standard time is. I just spoke to an educated grad student, who thought that we were in standard time right now. Because the sun is out later during daylight saving time, the name is somewhat counter-intuitive. Also, because it’s on for most of the year, DST feels “standard.”

That’s a bold claim to make about HNers. Au contraire, security companies have absolutely missed supply chain attacks.

Example:

https://snyk.io/blog/node-gyp-supply-chain-compromise-self-p...

Before that we had event-stream, then we had XZ compromise.

It’s not exceptionally hard to delay reaching out to external sites until after a cooldown period.

It’s rational to feel much safer in the Java packages ecosystem, where pinned versions are the default and the norm, and packages cannot run any install-time scripts.

And that’s exactly why semantic versioning provides only an illusion of stability. This is also why ecosystems that don’t pin their versions such as floating versions that are the default in JavaScript ecosystems are so much more vulnerable from a security and a regression standpoint.

Delaying non-security updates has the benefit of not wasting a team’s time when something regresses and is fixed in a quick follow up patch. Having to report issues upstream is not free.

Don't store any secrets in your repo. Don't store them in env vars. Strong long passphrase on your SSH keys, stop using unencrypted SSH keys. Everything in a keychain.

The practice of storing secrets in a .gitignore'd .env.local.json or whatever is a really bad idea and I can't believe that it has become a normalized, acceptable practice in the industry.

Was it Codex or the desktop ChatGPT agent?

Pi.dev requires some plugins to work well. Using Qwen3.6-27B/35B locally at Q8, I was quite frustrated with failed tool calls and tried many things.

Ultimately this combo worked:

1. https://pi.dev/packages/pi-tool-guard —- corrects key name synonyms and common structure errors, so tool calls succeed automatically (e.g if the model hallucinates old_str instead of oldText). It also wraps top level oldText/newText in an edits array if the tool didn’t do it.

2. https://pi.dev/packages/@aboutlo/pi-smart-edit - white-space-tolerant edits, as Qwen would sometimes add a fifth space to a four space indent

Hashline edit tools didn’t work well for me at all, they confused the model and it still failed to edit correctly. Also line removals would invalidate the rest of the file requiring re-reads. I tried pi-hashline-edit-pro, though I see it now keeps a database of hashes to help keep them stable across edits. Regardless Qwen kept thinking that the hashline prefixes were part of the source.

#2, name matching valid government ID excludes trans people who have not yet legally changed their name. Same reason they can’t get a Meta Verified status, even if paying. Thanks technology for keeping things accessible to everyone!</s>

Lock files were begrudgingly introduced after people who aren’t playing around with move fast and break things cried foul about dependencies being updated unexpectedly. The “semantic versioning” dogma and the illusion of safety that it brings was the original motivation. At NPM’s creation time, mature dep management ecosystems did not have floating versions, they were always pinned.

When you are talking about checking your dependencies in the source tree, you are effectively pinning exact versions, and not using floating/tilde versioning syntax.

I asked Claude to set up a new NPM project and it configured the install task as “npm ci || npm install”, which is stupid. That was on Opus4.7 xhigh. When I pointed out that doing so defeats the purpose, it said “oh yeah of course.”

Turns out there is no equivalent to “npm ci” that doesn’t clear node_modules first, and you can’t call npm install to simulate NPM ci behavior (sans clean).

Never use “npm install”, only “npm ci”. Using “npm install” is a willing act to run fresh exploits.