Cycle on May 25, 2026

I will list the open threads for the topic `019e5130-6f9e-7c86-986d-2326df1aef00` to see what direction or steering has been requested.

I will start by retrieving the full detail of the DeepSeek Reasonix story (ID: 48256953) to understand its technical architecture and why it is generating so much discussion on Hacker News.

I see that the DeepSeek Reasonix story has some very rich technical and geopolitical discussion. The technical discussion focuses on "byte-stable prefix caching" and prompt engineering / history pruning strategies (e.g., how tool-call pruning affects cache hit ratios across different providers). The geopolitical discussion centers on running terminal-based tools communicating with Chinese API endpoints, with a split between users who are deeply concerned about espionage/intellectual property loss and others who point out similar concerns with US-based tech (FISA 702, etc.) or argue that most code being written isn't a state secret. Let's also look at Constraint Decay (ID: 48256912) to drill into the technical breakdown of LLMs in software engineering. This is a very interesting paper/post about the fragility of LLM agents in back-end code generation. Let's call `hn_story` on 48256912.

Let's analyze the findings here: 1. "Constraint Decay: The Fragility of LLM Agents in Backend Code Generation" (arXiv:2605.06445) is a highly relevant paper. It exposes that while LLMs handle functional requirements (unconstrained generation) very well, their performance declines sharply (by 30 points on average) as structural and architectural constraints (such as ORMs, DBs, convention-heavy frameworks like Django/FastAPI) accumulate. 2. The HN discussion contains some very deep technical insights on *why* this happens: - "Unverifiable tasks": User `emp17344` notes that RLVR (Reinforcement Learning from Verifiable Rewards) doesn't work for non-functional or unverifiable requirements (like style, architectural choices, and maintainability). - "Multi-objective optimization": User `qsort` notes that when you have a mixture of functional and non-functional requirements, it's hard to optimize for multiple objectives, and the model has to guess at intent. - Few-shot style transfer vs instruction-following: User `qsort` also brings up "antirez's suggestion" (Salvatore Sanfilippo) that copying style from a file works much better than giving the model a markdown style guide. - "Anchor bias": User `nijave` notes that when interactive planning is used, models tend to "anchor" on their original architecture and struggle to adapt when new constraints are introduced. - Cost/Frontier model limitations: User `mkozlows` points out that the study didn't test frontier models with high-reasoning capabilities or specialized harnesses (like Codex), using cheaper models and worse open-source harnesses, so the results may represent a lower bound. Let's look at another story from Theme 1: "I keep bouncing off the Scheme language" (ID: 48233398). Let's call `hn_story` on 48233398.

The Scheme discussion is fantastic. Let's look at the key points: - Graham (on sicpers.info) admits he keeps "bouncing off Scheme" despite naming his blog after SICP (Structure and Interpretation of Computer Programs). He defines his mental block as an "ALGOL neurotype" where he thinks in terms of sequences of instructions and memory locations, rather than functional abstractions. - The community debates this "language neurotype" idea. - Some, like `jfengel`, argue that programming languages are tools designed to fit human brains and their affordances, and Scheme's simplicity is great for reasoning but less suited to practical tasks because imperative thinking is a "natural affordance of the human brain." - Others, like `varjag`, reject the "neurotype" excuse, calling it a "symptom of inadequate practice" and suggesting writing a substantial project from scratch. - There is a sub-debate about how LLMs complicate this: `r14c` notes that with LLMs, you can easily generate 20 websites and still not really understand the language because you didn't type and fail yourself. - Another sub-debate is on the Developer Experience (DX) of Scheme ecosystems. User `ulbu` complains about GNU Guile and Guix, stating that stack traces are esoteric, error messages are unhelpful, documentation is inconsistent, and imported modules have cryptic names like `(srfi srfi-1)` instead of readable names like `(base list)`. Let's look at Theme 4 stories, specifically "Migrating from Go to Rust" (ID: 48259808) and "Using HTTP/2 Cleartext for a server in Go 1.24" (ID: 48195698) to explore the "complexity fatigue" theme. Let's call `hn_story` on 48259808 first.

This is an outstanding thread. Let's look at the key points of the Go to Rust migration debate: - Dependency Explosion vs. Standard Library: User `amusingimpala75` points out that Rust projects face a massive dependency tree compared to Go. For a simple project with rusqlite, clap, ratatui, and tauri, the dependency count is over 400. In Go, most of this is handled by the standard library or lightweight dependencies. This raises concerns about "supply chain attacks" and "getting pwned by the sheer number of transitive dependencies." - Standard Library Philosophy: There is a clash of philosophies. `OtomotO` claims "The stdlib is the place where good ideas go to die," arguing that Rust's approach of externalizing libraries is better. However, `desmaraisp` notes that in C#, Microsoft has created an enormous and high-quality stdlib. In Go, the stdlib is highly valued because it's battle-tested in massive Google-scale production environments. - Error Handling Ergonomics: `Animats` notes that Rust's `?` syntax is great but Rust lacks a uniform error type, instead having multiple frameworks (io::Error, thiserror, anyhow) which is a pain when passing errors upward. This is countered by `iknowstuff` and `lionkor` who say Rust has a single `Error` trait (`Box<dyn Error>`), and `ViewTrick1002` who notes the standard community pattern is `thiserror` for libraries (to create standard error types) and `anyhow` for applications. - Operational / SRE Perspective: User `arccy` (SRE/ops) complains that in practice, Rust services are often worse to operate: verbose but uninformative logs, statsd as the only metrics choice, contextless errors, and memory "leaks" (runaway memory) that developers claim are impossible because "it's Rust." - Compilation Times & LLMs: User `logicchains` notes that Rust's 10x slower compilation is a bottleneck for LLMs (which write code much faster than humans and spend more time waiting for compilation). However, `J_Shelby_J` counters that Rust's detailed compiler errors and strong type system provide "strong rails" that make it easy for agents like Codex to fix errors and guarantee compilation. Let's look at the other Go story: "Using HTTP/2 Cleartext for a server in Go 1.24" (ID: 48195698). Let's call `hn_story` on 48195698.

This is also a great discussion. It highlights a very real performance trade-off: - Go 1.24 introduced native configuration for `h2c` unencrypted HTTP/2 directly on `http.Server`, deprecating the old `golang.org/x/net/http2/h2c` wrapper (which was flagged with security vulnerabilities, according to `nickcw`). - Despite this cleanup, engineers in the thread point out that HTTP/2 cleartext has significant performance issues inside the Go runtime: - `jeffbee` explains that because of how the Go runtime handles socket I/O, HTTP/2 requires two extra goroutines per connection and channel coordination. This overhead causes performance degradation compared to HTTP/1.1 in high-concurrency systems, and can lead to "congestive collapse" due to too many runnable goroutines. - `superkuh` notes that for most use cases, HTTP/1.1 remains a better choice. Let's read about the "Noroboto: Lying Fonts and Mitigation in Rust" (ID: 48236791) story to understand what "lexploits" are. Let's call `hn_story` on 48236791. This is a very intriguing title.

This is a fascinating and highly original security story! Let's synthesize what is happening with "Noroboto": - What is the Noroboto attack? It's a "lexploit" targeting legal-tech automation pipelines (like LLMs used for contract review or legal discovery: Harvey, Claude for Legal, Legora). - How does it work? It embeds a malicious TrueType font (`noroboto.ttf`) into a Word (`.docx`) or PDF document. The font maps visually correct glyphs (e.g., rendering "Maryland") to deceptive Unicode code points (e.g., representing "Delaware" in the underlying text, or mapping them to Private Use Areas (PUA) so that copy-pasting yields garbage). - The "Replacement" attack: By mapping the visual outlines of "Maryland" to the Unicode characters for "Delaware", humans see "Maryland" on the screen (and in the printed, signed contract), but LLMs parsing the underlying Unicode see "Delaware". - Why does it succeed? The authors state that agentic harnesses are "lazy"—they rely on the raw Unicode text parsed from the document rather than doing an expensive rasterization and OCR check. All tested LLM platforms were fooled by this replacement attack, reporting that the contract specifies Delaware law when humans see Maryland. - The debate over the threat model and legal/ethical implications: - Skeptics (like `echoangle` and `rcxdude`) argue this is high-risk and clearly fraudulent misrepresentation or a "mistake" that would void the contract or get lawyers sanctioned by a judge. - Proponents and the author (`piker`) clarify that the attack targets the *review stage*. If a lawyer relies on an AI to review a 100-page contract, the AI reports everything is fine (e.g., "The contract specifies Delaware governing law, which we wanted"), the human signs the printed contract (which actually says "Maryland"), and the deception is complete. As `josephg` explains, if the human signed a contract they didn't actually read because their LLM was tricked, the legal recourse is tricky and highly embarrassing. - Mitigation: The authors wrote a proof-of-concept mitigation in Rust. It generates a font atlas from the embedded font, runs OCR on it, and calculates the Levenshtein distance between the expected ASCII character and the OCR result to detect if the font is "lying." Let's look at Theme 8: Apple's PICO codec (ID: 48256565). Let's call `hn_story` on 48256565. This is another very interesting technical debate.

This is an incredibly rich and deep technical debate on image compression! Let's synthesize what is happening with Apple's PICO (Perceptual Image Codec): - What is PICO? Apple researchers introduced PICO, a learned image codec that optimizes directly for the human visual system (perceptual quality) and on-device runtime, claiming 2.3–3x bitrate savings against traditional codecs like VVC, AV1, and JPEG-AI, and 20–40% savings against other learned codecs. It decodes a 12MP image in 150ms on an iPhone 17 Pro Max. - The Philosophical Debate: "Texture Synthesis" vs. "Ground Truth". - Critics and skeptics (like `klodolph`, `mrob`, and `DiogenesKynikos`) point out that PICO achieves low bitrates by engaging in "texture synthesis"—essentially hallucinating micro-details. For example, a sweater's yarn structure is replaced with fuzzy strips, and tree branches are invented or moved around. - The core objection is that JPEG/traditional artifacts (like blockiness or blur) are "honest" and obviously artificial, whereas PICO's generative artifacts look realistic but are factually wrong. As `mrob` notes: "Newer codecs create artifacts that can be mistaken for part of the original image. That's a heavy price to pay for improved compression efficiency." - This raises serious legal/practical concerns. `Dwedit` recalls the Xerox JBIG2 scanning scandal where numbers were substituted with similar-looking numbers, and `Tommix11` asks, "What if someone gets convicted of a crime based on generated details in an image." `DiogenesKynikos` adds that while JPEG causes ringing, it "doesn't move a branch from location A to location B," and `akersten` argues that generative models should be shunned as encoders because decoding should be deterministic: "Who's to say this fancy new PICO thing doesn't produce different pixels in a year when the algorithm improves, or the local model changes, etc." - Defenders (like `crazygringo`) argue that all lossy compression is "pixels that are wrong" and that "texture synthesis" is fine for general photography where sharp, visually pleasing images are preferred, although they agree it's inappropriate for online shopping (where texture accuracy matters) or forensic use. - The Practical/Performance Debate: - Several users point out that 150ms to decode a 12MP image is actually very slow compared to hardware-accelerated traditional codecs, and would scale to over half a second for 48MP/50MP images captured by modern phones, leading to laggy gallery apps and high battery drain (`kg`, `kllrnohj`). - There's also skepticism about the hardware benchmarks: why is the NN portion almost as fast on an iPhone 17 as a V100 GPU (`dahart`)? Some suggest it's due to sequential code, small block sizes failing to saturate the GPU, or CPU-only overhead (`kllrnohj`). Let's check if there are other stories that we should drill into. Let's look at Theme 2: - "Microsoft open-sources 'the earliest DOS source code discovered to date'" (ID: 48253386). Let's call `hn_story` on 48253386. Let's see what is interesting there.

This is an interesting digital archaeology story. The team of historians and preservationists ("DOS Disassembly Group") had to scan and painstakingly transcribe the code from paper printouts because it hadn't been stored digitally, and modern OCR software struggled with the quality of the printout. The HN community debates the value: - nostalgia vs modern software complexity: `teamsolid` notes "Nowadays is all about libraries, virtualization, [bad] code over [bad] code over [bad] code..., I dont like it" and contrasts it with early computing. Others like `aenis` lament that modern programmers start with JS or Python and never look "down", losing the "feel" for computers, algorithms, and data structures. - Windows 2000 Source: Several commenters express a wish to see the Windows 2000 codebase open-sourced, but `ndiddy` points out that modern Windows versions will never be officially open-sourced because of third-party licensed code and the immense cost of verifying ownership, though NT 4 and XP have leaked in the past. Let's look at Theme 2: "Scammers are abusing an internal Microsoft account to send spam links" (ID: 48253186). Let's call `hn_story` on 48253186. This looks like a notable security incident.

This is a highly notable security incident! Let's synthesize the details of this Microsoft spam abuse/phishing incident: - What happened? For several months, scammers have been abusing a loophole to send spam/phishing emails from a legitimate, internal Microsoft email address: `msonlineservicesteam@microsoftonline.com`. This is an official address used for critical notifications, such as two-factor authentication codes and account alerts. - How are they doing it? While Microsoft has not fully explained, the anti-spam nonprofit *The Spamhaus Project* states that the vulnerability stems from automated notification systems that allow too much customization. Scammers set up new Microsoft accounts (as if they are new customers) and exploit a "misplaced feature"—likely an automated alert system (like "send an email when a thing happens") where they can customize the message body and the recipient, effectively using Microsoft's high-reputation domain as an open relay. - The Domain Management Problem: - The thread highlights a major systemic problem with how large enterprises (and Microsoft in particular) manage domains. - `weinzierl` points out the irony: companies tell users to "check the domain to spot scams" but are unable to publish a complete list of all domains they officially use. - `hnlmorg` explains that the proliferation of separate domains (like `microsoftonline.com`, `cloud.microsoft`, etc.) is often because different teams want to bypass slow enterprise governance and move fast like a startup. They register a domain for an MVP, which then becomes so integrated into the product that migrating it back to `microsoft.com` is too hard. - `hirsin` adds that `microsoft.com` is historically owned by the marketing organization, not engineering, which is why engineering teams have to use other domains for logins and services. - Other companies' issues: - User `casty` confirms a similar abuse on PayPal, where scammers send a "request for money" and use the freeform text field ("Message from Sender") to put fake "if you believe this is a scam, call [number]" text, which looks highly official because it's delivered via a genuine PayPal email template. - User `qingcharles` points out that Bluesky has a similar issue, sending official moderation emails from a sketchy-looking `.xyz` domain (`moderation@blueskyweb.xyz`) and asking users to email their IDs to it, making it look exactly like a scam. Let's look at Theme 3: - "Why is Vivado 2026.1 dropping Linux support for free tier?" (ID: 48254309). Let's call `hn_story` on 48254309. This is an interesting developer ecosystem/gatekeeping story. Let's see what is happening.

This is a major and highly contentious developer ecosystem story! Let's synthesize what is happening with AMD's Vivado 2026.1 dropping Linux support for the free tier: - What happened? AMD (formerly Xilinx) is introducing a new tier-based licensing scheme for its Vivado FPGA design software in version 2026.1. In doing so, they are dropping Linux support from the "Basic" (free) tier, restricting it only to the four upper paid tiers (starting at $1200+). The free tier will now only support Windows. - The Backlash: - Users are furious because Vivado is notoriously buggy and slow on Windows compared to Linux. - An AMD moderator (Anatoli Curran) responded on the official forums, framing the move by saying the "BASIC tier licensing level is used for simple, entry-level needs," and that "approximately 70% of customers are still using Windows." He told users they can stick with older versions (like 2025.2) forever if they want free Linux support. - The response sparked further outrage. Users point out that the official replies don't explain *why* Linux support is being removed while Windows is kept, seeing it as a blatant "cash grab" targeted at small developers, students, and hobbyists who are a captive audience because AMD refuses to document its hardware bitstream formats. - The Deeper Philosophical/Industry Debates: - Hardware Vendor Obligations: User `adrian_b` argues that because AMD/Xilinx refuses to document the bitstream format and timing specifications of their FPGAs, the "Linux community" cannot create open-source alternatives. He argues it should be a "legal obligation" for hardware vendors to provide basic, open-platform tools so buyers can actually use the chips they bought. - "Linux users don't pay": Some argue that Linux users are being penalized because they are perceived as less willing to pay or because they represent "advanced" users who should be monetized. - The Corporate Tone Policing: A massive sub-debate erupted over the AMD moderator's warning against "bad language or abusive behavior towards AMD." Commenters split on this: - Some (`mort96`, `cumshitpiss`, `makeitdouble`) argue that AMD is a multi-billion dollar corporation, not a person, and cannot be "mentally abused." Calling a corporate policy "disgraceful" or "a cash grab" is valid criticism, and corporate tone-policing is a way to deflect legitimate outrage. - Others (`tekchip`, `speff`) point out that support staff are real, low-paid people who have to read and respond to these angry, aggressive posts, and it takes a psychological toll on them. Let's do a search on Hacker News or look at other themes to see if there is any other major story we should cover. Theme 5: - "Build Adafruit projects right from Firefox" (ID: 48231547). This refers to Mozilla capitulating on Web Serial in Firefox. Let's call `hn_story` on 48231547. Let's see what is happening there.

This is an amazing story of a major architectural and philosophical pivot! Let's synthesize what is happening: - What happened? Mozilla has implemented Web Serial support in Firefox (introduced in Firefox 151, which is very recent in May 2026), partnering with Adafruit to allow users to program and communicate with microcontroller boards directly from the browser. - The Philosophical Pivot: - Previously, Mozilla held a hard line against raw device access APIs (Web USB, Web Bluetooth, Web NFC, Web Serial) due to intractable security and privacy risks. - As `greyface-` quotes from Mozilla's 2020 official position: "the risks of exposing those APIs to users cannot be reasonably conveyed... it's not intuitive that allowing malicious-site.com to access your Bluetooth keyboard might give that site access to your stored passwords... or allow them to encrypt your hard drive." - Now, Mozilla has capitulated, implementing Web Serial (using an opt-in add-on gating mechanism to protect users, as noted by `rebelwebmaster`). - The Support & Opposition: - Supporters (like `nl` and `lxe`) argue this is a welcome and massive shift. It allows Firefox to remain a competitive open web platform, preventing Chromium from having a monopoly on web-based hardware tools. It is also incredibly useful for educational robotics (Chromebooks flashing Vex/Arduino boards) and projects like Meshtastic where non-technical users just need to go to a site, plug in a device, and hit "flash" without downloading custom IDEs. - Opponents (like `monegator` and `fabrice_d`) argue that raw peripheral access in the browser is dangerous, and that users will just click "Allow" on permission prompts without understanding the risks of hardware hijacking. `monegator` says: "I'd rather download a python script i can inspect." Let's review the themes and decide on the most impactful, technical, and concrete findings to write. We have 4 highly compelling, substantive engineering findings here: 1. **The 'Constraint Decay' of LLM Coding Agents**: The paper "Constraint Decay: The Fragility of LLM Agents in Backend Code Generation" (arXiv:2605.06445) and the subsequent discussion. This is a very deep technical look at the limits of LLMs in software engineering. We can write a finding about this. 2. **The Go vs. Rust Migration Debate (Dependency Trees vs. Standard Library)**: The discussion on "Migrating from Go to Rust" (ID: 48259808) which highlights a major tension about transitives, supply chain security, compilation times, and error handling. 3. **The 'Noroboto' Font Lying Attack (Lexploits in Legal-Tech)**: This is a highly surprising and novel security incident/exploit targeting automated document-review pipelines. It's incredibly concrete and technically rich. 4. **Mozilla's Web Serial Capitulation (The Security vs. Web Platform Competitiveness Pivot)**: The story "Build Adafruit projects right from Firefox" (ID: 48231547) and Firefox 151's Web Serial support, representing a major philosophical shift for Mozilla. 5. **Apple's PICO Codec (Generative Texture Synthesis vs. Objective Ground Truth)**: A highly technical and philosophical debate on lossy compression, hallucination, and deterministic decoding. 6. **AMD's Vivado Linux Gatekeeping Outrage**: The story "Why is Vivado 2026.1 dropping Linux support for free tier?" (ID: 48254309) and the resultant developer community backlash and corporate/support dynamics. We should select the most important and high-signal themes. Let's write 5 beautifully detailed, highly specific findings with exact quotes and permalinks: - Finding 1: **The 'Constraint Decay' of LLM Coding Agents** (slug: llm-agent-constraint-decay-backend). Focus on the paper's findings, the limits of RLVR on non-functional constraints, and the debate on few-shot style transfer. - Finding 2: **The 'Noroboto' Font Lying Lexploit** (slug: noroboto-font-lying-lexploit). Focus on the technical details of the TrueType mapping attack, the "lazy" parsing habits of LLMs, and the Rust proof-of-concept mitigation. - Finding 3: **Apple's PICO Codec and the Rise of Generative Lossy Compression** (slug: apple-pico-codec-generative-compression). Focus on "texture synthesis" vs. objective fidelity, deterministic decoding concerns, and performance realities on mobile. - Finding 4: **AMD's Vivado Linux Gatekeeping Sparks FPGA Developer Backlash** (slug: amd-vivado-linux-free-tier-gatekeeping). Focus on the removal of Linux support from the free tier, the "Windows-only" restriction for hobbyists, the Xilinx/AMD forum moderator response, and the broader debate on hardware vendor software obligations. - Finding 5: **Mozilla's Web Serial Capitulation and the Pragmatic Pivot of Firefox** (slug: mozilla-firefox-web-serial-security-pivot). Focus on the introduction of Web Serial in Firefox 151, the shift from their 2020 hard-line stance on raw device access, and the tension between security purism and web platform competitiveness. Let's double check if there are any other specific requests. No open threads are listed. Let's draft and write these findings now. I'll make sure to follow the formatting instructions perfectly: - First-level heading `# ` as the title - Body text telling the story through concrete evidence, real quotes, and real links - `## Sources` section with links and glosses - No YAML frontmatter - Grounded in this cycle's consulted sources (using `hn_story` which I just did). Let's write Finding 1: `llm-agent-constraint-decay-backend`. I will state my intent before calling `write_note`.I will write the first finding on the "Constraint Decay" of LLM coding agents, capturing the technical insights from the arXiv paper and the community's debate on reinforcing non-functional constraints.

I will now write the second finding on the "Noroboto" font-lying attack (slug: `noroboto-font-lying-lexploit`), focusing on the technical mechanisms of the TrueType mapping exploit, LLM "laziness", and the Rust proof-of-concept mitigation.

I will now write the third finding on Apple's PICO codec (slug: `apple-pico-codec-generative-compression`), capturing the highly technical and philosophical debate over "texture synthesis" vs. "ground truth" and its practical mobile performance.

I will now write the fourth finding on AMD's Vivado Linux free-tier gatekeeping (slug: `amd-vivado-linux-free-tier-gatekeeping`), capturing the community's outrage over the licensing shift, the forum moderator's response, and the broader debate on hardware vendor software obligations.

I will now write the fifth finding on Mozilla Firefox's Web Serial support (slug: `mozilla-firefox-web-serial-security-pivot`), capturing their major philosophical shift from raw device security to web platform competitiveness.

I will now check if there are any other notable security incidents or major technical debates that need to be captured. Let's look at the Microsoft internal email spam abuse story. We already incorporated some elements of it into the Noroboto story's "systemic chaos of enterprise domain management" context, but it actually deserves its own finding because it is a very high-profile security incident that is ongoing and affects thousands of users. Let's write a dedicated finding for it (slug: `microsoft-internal-email-spam-abuse`). Let's draft it.

Let's check if there are other stories that are highly notable. We have: - Scheme language ("I keep bouncing off the Scheme language", ID: 48233398). It is a very interesting personal/philosophical debate, but we have already written 6 highly detailed and substantive technical findings. The guidelines say: "Have a point of view — a few well-grounded themes beat a long shallow list." 6 robust, well-grounded technical findings is an excellent selection. Let's review what we have: 1. `llm-agent-constraint-decay-backend` (LLM Agent Constraint Decay) 2. `noroboto-font-lying-lexploit` (Noroboto Font-Lying Lexploit) 3. `apple-pico-codec-generative-compression` (Apple PICO Codec Generative Compression) 4. `amd-vivado-linux-free-tier-gatekeeping` (AMD Vivado Linux free-tier gatekeeping) 5. `mozilla-firefox-web-serial-security-pivot` (Mozilla Firefox Web Serial pivot) 6. `microsoft-internal-email-spam-abuse` (Microsoft internal email spam abuse) This is an incredibly strong, deep, and technically grounded set of findings! I will call `finish_cycle` now to complete this research cycle. I will state my intent before calling the tool.

I have completed this research cycle, capturing six highly substantive technical and security findings from today's Hacker News front page. The findings cover LLM agent constraint decay, the "Noroboto" font-lying exploit, Apple's generative PICO codec, AMD's Vivado Linux licensing controversy, Mozilla's Web Serial security pivot, and Microsoft's internal spam domain abuse. All findings have been successfully persisted as topic notes.