Qwen 27B Beats Opus, uBlock's Last Browser, FHE Gets Real

Good morning. It's Saturday, August 15, and we're covering the small open model that outscored a frontier flagship on two agentic coding benchmarks, the browser that became the last safe harbor for uBlock Origin, and Google's push to make encrypted AI inference something you can compile.

Qwen3.8-27B held 1,147 points and 698 comments by morning - the top story on Hacker News and the second open-weights release from the Qwen3.8 family this week. The Firefox and uBlock Origin thread crossed 1,044 points, and the "Why does Opus 5 feel worse to work with?" essay drew 873 points and nearly 800 comments.

In today's brief:

• Qwen3.8-27B: a 27B dense vision-language model, Apache 2.0, that scores 61.7 on SWE-bench Pro and 42.2 on DeepSWE 1.1 - ahead of Opus 4.6 Max on both - with a native 262K context and a 1M extension path
• Firefox is now the last major browser that still supports uBlock Origin, as Chromium's extension lockdown ripples through Edge and Brave
• Google showcases HEIR, an open-source compiler that turns trained models into homomorphic-encrypted inference with hardware-accelerator partners
• Anthropic publishes the economics of a Claude Code session - what busts your prompt cache, what doubles your bill, and what costs nothing to fix

THE BIG ONE

Qwen3.8-27B: A Laptop-Sized Dense Model That Outscored Opus on Its Own Benchmarks

Qwen released Qwen3.8-27B on Hugging Face yesterday as an FP8-quantized, Apache-2.0 open-weights model - the first 27B dense member of the Qwen3.8 family, following the 2.4T-parameter mixture-of-experts flagship that dropped Wednesday. The numbers are the story: on SWE-bench Pro, Qwen's own evaluations (run with the Claude Code harness, temp 1.0, 256K context) put the 27B at 61.7% against 53.4% for Opus 4.6 Max; on DeepSWE 1.1 it scores 42.2% - up from 13.3% for Qwen3.6-27B and above Opus 4.7 Max's 40.0 in community runs; and on QwenSWEBench, an in-house software-engineering benchmark, it jumps from 49.3% to 79.0%. The HN thread greeted it with variations on "Opus at home": a dense 27B model - roughly 30 GB of FP8 weights - that community testers are running on Strix Halo laptops and RTX 4090s. Unsloth had GGUF quants and NVFP4 variants up within hours.

Architecturally this is the interesting release to study. The model is a hybrid: 64 layers in a repeating pattern of three Gated DeltaNet linear-attention blocks followed by one full attention block, which is how a 27B model holds a native 262,144-token context with the option to extend past a million via YaRN. It is natively multimodal - images and hour-scale video - which shows in the agentic numbers: OSWorld-Verified at 84.3% (Opus 4.6 Max: 72.7%), WebArena-Verified at 64.8%, AndroidWorld at 81.9% (Opus: 62.0%). Thinking mode is on by default with a reasoning_effort of xhigh / medium / low, and preserve_thinking keeps reasoning traces across turns for agent workloads. Qwen Cloud says a hosted version with 1M context by default is coming soon. The thread's skepticism is worth keeping too: the usual caveats about vendor-run evaluations, the observation that HLE (30.8%) still trails the frontier by ten points, and one HN commenter's reminder that their own repo-level evals are the only numbers that count. The benchmark table's fine print - all open baselines re-run on the Claude Code harness with corrected tasks - is the part to read before quoting any of this as gospel.

Why it matters: The open-weights ceiling for agentic coding on consumer hardware just moved decisively - a 27B model that beats a frontier flagship on two agentic benchmarks means "frontier-grade coding agent" now has a local, license-free option, and every team that prices agent fleets gets a new number to plan around.

SECURITY

Firefox Is Now the Last Major Browser Where uBlock Origin Still Works

PCWorld's headline states the new browser reality flatly: Firefox is the last major browser that still supports uBlock Origin (1,044 points, 392 comments). Chrome disabled Manifest V2 extensions in 2024, leaving uBlock Origin Lite - a declarative-net-filter approximation - as the only uBO variant that still functions; Microsoft Edge is about to do the same, locking out older ad blockers just as Chrome did; Brave, despite its built-in shields and an MV2 opt-out for uBO, is Chromium underneath and is caught in the same timeline; Opera and Safari walked away from full uBO support long ago. That leaves Mozilla's browser as the single mainstream holdout running the full, open-source uBlock Origin with its procedural cosmetic filtering and dynamic filtering intact.

The HN thread does two things at once: it argues about whether Brave's built-in blocker is a legitimate substitute (its proponents point to shield defaults and cross-platform support; its critics to the MV2 opt-out being on a timer and to Brave's Chromium lineage), and it hashes out the deeper consolidation story - one commenter's line that "since Opera gave up on Presto and Edge gave up on Trident, we've seen a massive and sudden consolidation towards Chromium" got wide agreement, with the IE-era lesson attached. For developers, the practical takeaway is about extension ecosystems, not just ad blocking: Firefox's refusal to follow Chromium's API contraction means it remains the test bed for extensions that Chrome's platform simply cannot host anymore. If your project ships a browser extension, the "last browser standing" argument now applies to far more than blockers.

Why it matters: The extension platform is where browser power now concentrates - and with every Chromium fork locked to the same Manifest V3 wall, Firefox's support for richer extension APIs is the only counterweight left, which makes it the default target for any extension that does more than Chrome allows.

THE DEBATE

"Why Does Opus 5 Feel Worse to Work With?" Tops 800 Comments

The most-commented developer essay of the week is a personal post from a working engineer arguing that Opus 5 - despite being more capable, by the author's own admission, "even rivals Fable in benchmarks" - feels like a downgrade next to Opus 4.7, 4.8, and Fable when used as a coding agent (873 points, 794 comments). The thesis: the models the author liked "stop and ask questions if my intent was unclear, don't make assumptions without checking, and don't reinterpret or update my plans without asking," while Opus 5 requires "careful babysitting." The author's explanation is that benchmark-driven training - RLVR-style rewards on self-contained tasks - inherently selects for models that "make bold, usually-correct assumptions in the face of ambiguity," because a benchmark task is solvable without clarification, while real engineering context is always incomplete.

The thread is a genuine argument rather than a pile-on. The counter-position, argued in several long comments: benchmarks are "totally unreliable" as a proxy for felt experience, but the felt experience is also unquantified, and the only resolution is your own eval set - one commenter with a 250-task Rust/C embedded-systems eval reports Qwen3.6-27B within 4% of Opus 4.8 pass@1, and the thread's advice converges on "the only benchmark that matters is your own." It is a useful companion to the week's model news: the same day a 27B open model outscored Opus on paper, a chunk of the community was arguing that the paper numbers and the working experience have decoupled in the other direction - which is exactly why our own model-by-model coverage keeps returning to the same verdict: run the eval that matches your repo, not the leaderboard.

Why it matters: If the felt-quality gap between "asks when confused" and "assumes and proceeds" is real, the next frontier of agent UX is behavioral, not benchmark-driven - and the models that feel best to work with may not be the ones at the top of the tables.

RESEARCH

Google's HEIR Compiler: Encrypted Inference as a Build Target, Not a Research Project

Google's security blog showcased HEIR (Homomorphic Encryption Intermediate Representation), an open-source compiler that converts pre-trained AI models into versions that run on encrypted inputs - inference where the server never sees the data (394 points, 240 comments). The post, by staff software engineer Jeremy Kun, argues the homomorphic-encryption cost curve has crossed a threshold: "while homomorphic encryption has a nontrivial cost overhead, it shifts the capability/privacy trade-off to a question of cost. And the cost of homomorphic encryption is rapidly decreasing." HEIR's pitch is that manually converting a program to FHE currently "requires a team of cryptographers," and the compiler's goal is a "one-click solution to enable non-experts to incorporate encrypted inference into production applications."

The proof is four compiled applications with single-threaded CPU latency numbers, all open in the google/fully-homomorphic-encryption repo: a Deep Learning Recommendation Model (with Belfort Labs, LG, and NYU) that serves private content recommendations, a credit card fraud detector (with Niobium and hardshell.ai), a Kitsune network-intrusion detector that flags anomalies in encrypted traffic without decrypting it, and a hotword detector that lets an agent listen for triggers without exposing audio. Hardware partners - Belfort Labs, Niobium, Cornami, Optalysys - are building FHE accelerators, and the project has four peer-reviewed publications from collaborations with Georgia Tech, CMU, UCSB, Tsinghua, and others. For developers the honest read is the one the HN thread lands on: these demos are real but narrow - the numbers are per-application, single-threaded, and the "recommendations without seeing features" demo is a long way from general LLM inference. Still, a compiler toolchain with vendor-neutral IR (MLIR-based, like the rest of Google's compiler stack) is how a technology stops being a research field and becomes a build target.

Why it matters: Private AI inference with purely cryptographic guarantees - no enclaves, no data-sharing agreements - becomes a compile-time choice rather than a research project, which changes what "privacy-preserving" can mean in regulated industries with data the model provider must never see.

PLATFORMS

Anthropic Publishes the Real Economics of a Claude Code Session

Anthropic's Lydia Hallie published "Maximizing the value of your Claude Code sessions" (227 points, 33 comments), a 5-minute read that finally explains the agentic-coding bill in concrete terms: the same completed task can cost different amounts depending on session hygiene, and three things decide the price of a token - model, input vs output, and cache state. The numbers are the useful part: prompt-cache reads cost 0.1x the input price and writes up to 2x; the cache key includes the model, the effort level, and fast-mode, so switching either mid-conversation re-prefills the entire history at full price; and the cache expires after one hour on a subscription or five minutes on an API key (ENABLE_PROMPT_CACHING_1H=1 extends it). A typical small fix, the post walks through, is five requests where every one re-sends the whole conversation - which is fine when the prefix is cached and expensive when it is not.

The operational advice is concrete and cheap: run /clear between tasks so unrelated context stops riding along; /context in a fresh session to see what is actually loaded (the post suggests moving workflow-specific instructions into skills and toggling unused MCP servers with /mcp); @-mention a file instead of naming it, which attaches it to the first request and skips a Read call; put quiet flags on noisy commands in CLAUDE.md or hand the job to a subagent, because every line of command output joins the conversation and stays there; /rewind instead of /compact when only recent turns went sideways (rewinding costs nothing cache-wise); and run /compact before walking away, while the cache still makes the summary cheap. Two details land the point about how agents bill: MAX_THINKING_TOKENS=0 turns thinking off for a session below /effort low (except on Fable 5), and a /loop in an idle session fires a full turn carrying the entire conversation - run loops from a fresh terminal.

Why it matters: With agentic coding now metered per token, session hygiene is a cost-control skill - and Anthropic publishing the exact cache semantics means every tool built on token metering gets the same price-engineering playbook.

TOOLS WORTH A LOOK

1. RustDesk now supports true unattended remote access on Wayland (free/OSS, 297 points) - the release closes the long-standing Wayland gap in open-source remote desktop, bringing headless password-authenticated sessions to a platform that previously forced insecure fallbacks.
2. eigendrum (free/OSS, MIT, 162 points) - draw a shape and hear it as a real drum: a browser-based finite-element eigenvalue solver for the vibrating membrane, verified against closed-form spectra to better than a tenth of a percent, with the famous Kac drums built in to hear isospectral shapes.
3. Racket v9.3 (OSS, 89 points) - the release continues the language workbench's steady cadence; the thread's practical take: the ecosystem's batteries-included "a language to make languages" story keeps compounding.

WHAT ELSE IS HAPPENING

• Jane Street takes a $15B hit (122 points): the firm's mark-to-market loss after the meltdown at AI trading fund Situational Awareness, where it was an investor - Citadel won the ensuing bid war for the fund's positions; Jane Street still shows $40B in net trading revenue for the year, per the FT's sources.
• Going Dark, and the era of law enforcement hacking (346 points): Matthew Green on why device encryption and the shifting of interception to the endpoint changes what "surveillance" means - a short, clear primer (2 min read).
• RISC-V: They Should Have Known Better (166 points, 170 comments): Dmitry Grinberg's long-form technical critique of the ISA - interrupt-latency arithmetic, the optionality maze, encoding complaints, and the claim that "approximately none" of today's RISC-V SBCs will ever run Ubuntu LTS (long read).
• AI by Hand (307 points): Prof. Tom Yeh's hand-calculated-AI seminars - working through Qwen 3.6, Gemma 4, and fine-tuning by hand in spreadsheets - keeps drawing a crowd that wants to see the math, not the API.
• Stop sending me huge PRs; a rant (120 points): a working developer's complaint about 3,000-line pull requests gets the predictable but useful counter-signal from the thread - small PRs are a property of how work is sliced, not of willpower.

---

Every link above goes to a primary source or our sourced coverage. Tomorrow's brief lands when the news does - subscribe to get it by email.