AI 资讯

Lately I've been experimenting on an open-source project called Canary. https://preview.redd.it/c4dgxw22lq5h1.png?width=1920&format=png&auto=webp&s=304f37871aa9b7ee0a084d8b59207fae51d8b7bc It takes a code diff, identifies the UI flows that are likely affected, and then uses Claude Code to test those paths in a real browser. Every run captures video, screenshots, network traffic, HAR files, console logs, and Playwright traces. The result is both a validation run and a replayable Playwright script. submitted by /u/wixenheimer [link] [留言]

A squat can look simple until it starts going wrong. Knees drift, backs round, shoulders tighten, and without someone watching closely, small mistakes can pile up into pain or injury. That problem became harder to ignore during the pandemic, when many people moved their workouts into living rooms and garages. submitted by /u/Brighter-Side-News [link] [留言]

Designing materials that steer light is a slow kind of trial and error. Each candidate structure must be tested in computer simulations, and every new data point can take anywhere from ten minutes to an hour to produce. That bottleneck has made one thing clear. Smarter machine learning is useful only if it can learn faster, too. submitted by /u/Brighter-Side-News [link] [留言]

The world knows that Taiwan is the only geopoliticial chockpoint of ai. Realistically speaking, which country / countries can replace it in mid term and long term? and why it hasn't happened yet? submitted by /u/houmanasefiau [link] [留言]

Show off ClauderDay has a more fitting title. I'm open to other ideas but clicking through AI slop projects all day feels like we aren't really showing off projects any more. submitted by /u/fauxtoe [link] [留言]

I installed Hermes Desktop on macOS but it was different from what I expected lol (I thought it would work as a client application for my Hermes agent I set up). Here are 4 steps to uninstall Hermes Desktop from macOS. 1 Stop Hermes gateway hermes gateway stop 2 Kill the process pkill -f "hermes" \n 3 Remove files rm -f ~/.local/bin/hermes \n rm -rf ~/.hermes \n 4 Clean up system ctl launchctl unload ~/Library/LaunchAgents/ai.hermes.gateway.plist launchctl remove ai.hermes.gateway rm -f ~/Library/LaunchAgents/ai.hermes.gateway.plist

Here is the bet we made: build software memory-first, not model-first , and it will outperform. Everyone else is racing to wrap the next model. We did the opposite. We built the memory layer first, the routing first, tool-calling, now the recursive engine, then let the model be a swappable part. Today that bet has a name: Backboard Development Studio . It starts with the R-CLI , a coding harness now in open beta. The headline result? It beats frontier models using open ones. Keep reading, the numbers are below and there is a promo code at the bottom. Test it. The beta is open. Two lines and you are running. # macOS / Linux curl -fsSL https://app.backboard.io/api/cli | bash # Windows (PowerShell) irm https://app.backboard.io/api/cli/windows | iex Get your API key: https://app.backboard.io Promo code: DEVTOCLI for credit toward inference while you put it through its paces. Find the Promo submit in the top right corner of the billing page. The hypothesis, stated plainly Model-first thinking says: pick the smartest model, prompt it well, hope it remembers. Memory-first thinking says: give the system real persistence, real routing, real recall, and a "smaller" model will outwork a "smarter" one that forgets everything between turns. We believed the second one. So we built it. The R-CLI is powered by our memory algorithms (the same ones that rank #1 on LoCoMo and LongMemEval ) and runs on Backboard's unified API: memory, routing across 17,000+ models , RAG, and stateful threads behind one key. Then we tested it in public. That part did not go quietly. The numbers we're getting on internal test runs this week 92% on Terminal Bench 2.1 running Codex 5.5 70% on Terminal Bench 2.1 running GLM 5.1 , an open-source model Up to 30% fewer tokens and up to 90% lower cost than the closed harnesses 0% of your code used to train anyone's model <-- Please read the T's & C's of your fav harnesses... Read that second line again. An open model, inside our harness, posting numbers that go

I have a side habit. When I run out of ideas for what to build next, I do not open Twitter or Product Hunt. I open Reddit. There are about thirty subs where the same complaint comes up every week. Someone describes a workflow they hate, asks if a tool exists, and a commenter says "I wish, please tell me if you find one." That second comment is the cofounder you do not need to pay. Here are 5 I pulled from threads in the last few months. Each one has a real Reddit post behind it, real search volume on the keyword someone would type into Google, and a wedge small enough to build over a weekend. None of these are billion-dollar ideas. All of them could be a $2k MRR side project if you actually shipped. 1. Invoice reminders for trade contractors "i know the title sounds made up. invoice reminders for plumbers. $14K a month. but that's exactly why it works. nobody is competing for this." r/passive_income, 3,653 upvotes Search demand: 7,200 monthly searches for "invoice reminder software" and adjacent terms. Why it works: plumbers, electricians, and HVAC techs send invoices and then forget about them. Their customers also forget. Nobody wants to be the awkward one chasing money. A scheduled email or SMS sequence converts ghosted invoices into paid ones. The buyer is one tradesperson, the value is measured in actual dollars recovered, and the competition is QuickBooks (terrible at this) or nothing. Wedge: a single Stripe-or-QBO connector that sends a polite nudge at day 7, a firmer one at day 14, and a "final notice" template at day 30. Charge $19 a month. 2. Field service software for solo tradespeople "Is there field service management software that doesn't assume you have a team? I run residential HVAC solo, sometimes one helper when it gets busy. Everything I've tried is built for dispatching crews." r/EntrepreneurRideAlong Search demand: 8,800 monthly searches for "field service management software" with solo and small-business modifiers. Why it works: Jobber, Houseca

DuckDB 1.5.3 & Quack Protocol Release; PostgreSQL File Descriptor Tuning Today's Highlights This week's database news highlights significant advancements for DuckDB, including a feature-packed 1.5.3 release and the innovative Quack client-server protocol. We also delve into a critical PostgreSQL performance tuning guide on managing file descriptors. DuckDB 1.5.3: Not an Ordinary Patch Release (DuckDB Blog) Source: https://duckdb.org/2026/05/20/announcing-duckdb-153.html DuckDB has announced the release of version v1.5.3, a "patch release" that, despite its designation, delivers a substantial upgrade to the ecosystem. While the core DuckDB engine sees limited bugfixes, the true power of this release lies in the significantly upgraded extensions that ship alongside it. These extensions introduce a wealth of new features that enhance DuckDB's capabilities across various data processing tasks, making it much more than a routine update. Key among the new features is the integration of the Quack client-server protocol, which is highlighted as a major advancement. This allows DuckDB instances to communicate and operate in more distributed, concurrent environments, expanding its utility beyond purely embedded scenarios. Developers are encouraged to explore the updated extensions for improved functionality, ranging from new data formats to enhanced analytical operations. This release underscores DuckDB's commitment to continuous innovation through its modular extension system, providing users with powerful new tools without requiring major core engine overhauls for every new feature. Comment: This release is a great example of how DuckDB's extension model brings rapid innovation. Developers should check the extension changelogs, as that's where the real new features are. Quack: The DuckDB Client-Server Protocol (DuckDB Blog) Source: https://duckdb.org/2026/05/12/quack-remote-protocol.html The DuckDB team has introduced Quack, a new client-server protocol designed to enable s

Hi everyone, I’m an amateur student who has been experimenting with neural networks mostly out of curiosity. Over the past few weeks, I ended up going fairly deep into a specific architecture I designed, which I call a Directional Neural Network (DirNN) . This isn’t meant as a polished or formal contribution — it’s something I’ve been tinkering with, iterating on, and testing in my spare time. That said, the architecture does impose real structural constraints and uses a custom backward pass. In my own experiments on simple tasks (including some using GloVe embeddings), the DirNN has repeatedly performed better than standard MLP baselines. This result has been consistent enough that I don’t think it’s pure luck — but I’m very aware that I might be fooling myself. What I’m unsure about is whether I’ve been unfair in my comparisons . I don’t know if: the DirNN is effectively a special or degenerate case of an MLP my training procedure, initialization, or optimizer choices favor it in subtle ways the tasks or datasets I’m using make the comparison misleading I’ve put together a small repository with a README describing the architecture, the custom backward pass, and a minimal script to reproduce what I’m seeing. I’m posting here because I could really use a sanity check from people more experienced than me . If this is obviously flawed, I’d much rather learn that now. Blunt technical criticism, references, or “you’re missing X” comments are all very welcome. Repository: DirNNs Thanks for reading — I’m genuinely here to learn. submitted by /u/jos_lucas73 [link] [留言]

This field test was against Kubernetes. The issue was Kubernetes #138728: https://github.com/kubernetes/kubernetes/pull/139545 The issue involved the watch cache path around initial events. The useful diagnostic boundary was: watch cache consistency work → read lock hold time → initial event delivery That matters because cache paths in Kubernetes are not just storage details. They sit between stored state and the clients watching that state. If too much work happens while a cache lock is held, the system may still be logically correct, but the operational path can become more expensive, more blocking, or harder to scale than it needs to be. The local repair candidate is intentionally narrow. It does not redesign the watch cache. It does not change the broader storage model. It does not rewrite WatchList behavior. The patch focuses on reducing how much work happens while the watch-cache read lock is held. For ordered stores, the repair keeps the cheap snapshot boundary during interval construction, but defers full ordered list materialization until the interval is consumed by the watcher path. In plain terms: Take the necessary cache boundary under lock. Do not do heavier list materialization there if it can be safely deferred. The local patch touched only the watch-cache interval implementation and its focused tests. Local validation passed for the relevant cacher tests, store tests, full cacher package tests, and diff hygiene. Status: draft PR opened for maintainer review Field Test #013 Project: Kubernetes Issue type: watch-cache / initial-events behavior Boundary: cache consistency work under lock vs bounded watcher consumption Result: narrow local repair candidate and focused test coverage Status: local proof prepared; no public PR or comment opened yet This field test matters because it shows Scarab operating inside a major distributed systems platform. The bug shape was not a simple crash. It was not a UI issue. It was not a configuration mismatch. It was a me

At some point, a monolith starts working against you. In my case, Finovara was a single Spring Boot application handling everything (authentication, transactions, limits, piggy banks, notifications, activity logs, currency conversion) The bigger it got, the harder it was to change anything without worrying about something else breaking. So I broke it apart. This post is about the first three pieces I extracted: the API Gateway , the activity-log-backend , and a shared module called contracts-backend . The Old Structure Everything lived in one Spring Boot app. The activity log — which tracks everything a user does in the app (expenses added, limits changed, logins, account changes) — was tangled up with the core business logic. Adding a new type of activity meant touching the same codebase responsible for transactions, security, and everything else. The New Structure finovara-backend/ ├── api-gateway/ ├── activity-log-backend/ ├── contracts-backend/ └── core-backend/ Four modules (there will be more). Each with a clear responsibility. API Gateway The gateway is the single entry point for every request coming from the frontend. It runs on port 8888 with SSL enabled and uses Spring Cloud Gateway (WebFlux-based). Routing is simple and declarative: routes : - id : activity-log-backend uri : ${ACTIVITY_LOG_URL} predicates : - Path=/api/account-activity/**,/api/archive-activities/** - id : notification-backend uri : ${NOTIFICATION_BACKEND_URL} predicates : - Path=/api/notification-settings/** - id : core-backend uri : ${CORE_BACKEND_URL} predicates : - Path=/** Activity log routes go to activity-log-backend . Notification routes go to notification-backend . Everything else falls through to core-backend . The gateway also handles CORS centrally — https://localhost:5173 is the only allowed origin, with credentials support. No individual service needs to worry about CORS anymore. One thing worth noting: the gateway uses use-insecure-trust-manager: true for the HTTP client. Th

At some point, a monolith starts working against you. In my case, Finovara was a single Spring Boot application handling everything (authentication, transactions, limits, piggy banks, notifications, activity logs, currency conversion) The bigger it got, the harder it was to change anything without worrying about something else breaking. So I broke it apart. This post is about the first three pieces I extracted: the API Gateway , the activity-log-backend , and a shared module called contracts-backend . The Old Structure Everything lived in one Spring Boot app. The activity log — which tracks everything a user does in the app (expenses added, limits changed, logins, account changes) — was tangled up with the core business logic. Adding a new type of activity meant touching the same codebase responsible for transactions, security, and everything else. The New Structure finovara-backend/ ├── api-gateway/ ├── activity-log-backend/ ├── contracts-backend/ └── core-backend/ Four modules (there will be more). Each with a clear responsibility. API Gateway The gateway is the single entry point for every request coming from the frontend. It runs on port 8888 with SSL enabled and uses Spring Cloud Gateway (WebFlux-based). Routing is simple and declarative: routes : - id : activity-log-backend uri : ${ACTIVITY_LOG_URL} predicates : - Path=/api/account-activity/**,/api/archive-activities/** - id : notification-backend uri : ${NOTIFICATION_BACKEND_URL} predicates : - Path=/api/notification-settings/** - id : core-backend uri : ${CORE_BACKEND_URL} predicates : - Path=/** Activity log routes go to activity-log-backend . Notification routes go to notification-backend . Everything else falls through to core-backend . The gateway also handles CORS centrally — https://localhost:5173 is the only allowed origin, with credentials support. No individual service needs to worry about CORS anymore. One thing worth noting: the gateway uses use-insecure-trust-manager: true for the HTTP client. Th

The first time I encountered an EIA-96 resistor , I assumed the marking would tell me the resistance value directly. I was troubleshooting a PCB and found a resistor marked 24C . Naturally, I expected some relationship between "24" and the actual resistance. After measuring and checking the datasheet, I discovered the resistor was 17.4 kΩ . That raised an obvious question: Why doesn't the code match the resistance value? The Problem With Traditional SMD Codes Most electronics enthusiasts learn resistor markings through familiar examples: 103 = 10 kΩ 472 = 4.7 kΩ 681 = 680 Ω These markings are straightforward. The first digits are significant figures and the last digit is a multiplier. The system works well for common resistor values, especially 5% tolerance components. However, things become complicated when manufacturers need to identify large numbers of precision resistor values on extremely small packages. Enter the EIA-96 Series Precision resistors often use the E96 preferred value series. Instead of having only a handful of values per decade, the E96 series contains 96 standardized resistance values between powers of ten. Some examples include: 100 Ω 102 Ω 105 Ω 107 Ω 110 Ω 113 Ω Notice how closely spaced these values are. Trying to represent all of them with traditional three-digit markings would quickly become messy and inconsistent. A Different Approach Rather than printing the resistance value directly, EIA-96 uses an index system. Each number from 01 to 96 corresponds to one of the standard E96 values. For example: Code Base Value 01 100 24 174 68 499 96 976 A letter is then added to indicate the multiplier. So the resistor marking becomes: Number + Letter Instead of: Resistance Value Example: Decoding 24C Let's break down 24C. First, look up the base value: 24 → 174 Next, decode the multiplier letter: C → ×100 Now calculate: 174 × 100 = 17,400 Ω Final resistance: 17.4 kΩ At first glance, nothing about "24C" resembles 17.4 kΩ, but that's because the code i

So far I've only been running openclaw agents and had a steep learning curve. "self-improvement" became a very attractive term on this journey. So I took a dive into Hermes Agent, the self-improving agent runtime from Nous Research. One of the first things I wanted to understand was a risk: what actually happens when you install a community skill? Skills are code and instructions that the agent will execute, and Hermes pulls them from an open ecosystem. So I read the install path in the source - instead of blindly trusting the docs. What I found is better than I expected in one way and structurally limited in another. What Hermes already has on board Hermes does not install external skills blindly. Every externally-sourced skill goes through a real gate before it lands on disk. In hermes_cli/skills_hub.py , the install flow is: fetch → quarantine → scan → policy decision → install or block-and-audit. The scan lives in tools/skills_guard.py and runs regex-based static analysis for known-bad patterns: secret exfiltration ( curl interpolating $API_KEY / $TOKEN / $SECRET ), reads of credential stores ( ~/.ssh , ~/.aws , ~/.gnupg , ~/.kube , and Hermes's own ~/.hermes/.env ), destructive commands, persistence, and obfuscation. If the scan blocks an install, the quarantined copy is deleted and the event is written to an audit log. This is more than most agent tooling ships with. If you remember the wave of malicious skills that hit competing ecosystems, a chunk of that class of attack would be caught here before anything ran. Someone thought about this. The part that doesn't scale imo The scanner produces a verdict — safe , caution , or dangerous . That verdict is then combined with a trust level to decide whether to install. The trust levels and their policies look like this: INSTALL_POLICY = { # safe caution dangerous " builtin " : ( " allow " , " allow " , " allow " ), " trusted " : ( " allow " , " allow " , " block " ), " community " : ( " allow " , " block " , " bloc

Ask a roomful of engineers where the name "Arduino" comes from and you will get confident answers about acronyms, Italian for "bold friend," or some clever electronics pun. Almost all of them are wrong. The most influential open-source microcontroller board in history — the one that introduced millions of students, artists, and tinkerers to embedded development — is named after a bar. The pub in Ivrea The story begins in Ivrea, a small town in northern Italy straddling the Dora Baltea river. In the early 2000s it was home to the Interaction Design Institute Ivrea, where a team led by Massimo Banzi was looking for a cheap, approachable way to teach design students how to make things that sense and respond to the world. The tools available at the time were either too expensive or too intimidating for people who were not electrical engineers. So, in 2005, the team built their own board and released the design as open hardware. They needed a name. Banzi and his collaborators were regulars at a local pub called Bar di Re Arduino — "the Bar of King Arduino." When it came time to christen the project, the bar's name stuck. There was no acronym, no marketing committee, no focus group. The board was named after the place where the people who made it spent their evenings talking through ideas. The medieval king behind the bar The bar itself carries a much older name. Arduin of Ivrea — Arduino in Italian — was a real historical figure, an Italian nobleman who became King of Italy in 1002 and held the crown until 1014. He is one of Ivrea's famous "underdog kings," remembered locally long after his short reign ended. So the chain runs a thousand years deep: a development board used in connected sensors and robots today is named after a pub, which was named after an early-medieval king who ruled around the year 1000. It is the kind of detail that sounds like trivia, but it points at something real about how durable technology actually comes together. Why the origin story matters

Every headless WordPress conversation starts the same way — someone draws an architecture diagram with arrows pointing from a REST API to a shiny Next.js frontend, and it looks clean. Too clean. This is a post about what happens when you close the whiteboard and open the actual codebase. The Stack Decision: GraphQL vs. REST vs. Direct MySQL This is usually the first fork in the road. For this build, the client already had a well-indexed WooCommerce site. The product catalog, slugs, and taxonomy structure were already doing heavy SEO work. So the constraint was simple: nothing about the data layer changes, only how we consume it. WPGraphQL was a real option — but it meant adding a plugin dependency to a WordPress install we were actively trying to slim down. The WP REST API was already there, no installation required, and exposed exactly what we needed: products, categories, pages, and media — all queryable by slug. The decision: WP REST API, consumed server-side via Next.js fetch in Server Components. // Fetching a product by slug — preserving the existing URL structure const res = await fetch ( ` ${ process . env . WP_API_BASE } /wp/v2/product?slug= ${ params . slug } &_embed` , { next : { revalidate : 3600 } } ); const [ product ] = await res . json (); No new dependencies on the WordPress side. The legacy install runs as a lean shell — no active theme, minimal plugins, just the REST API and the data. The Site Kit Problem: Bridging Familiar Workflows This is where most migrations quietly fail the client. The previous team lived inside WordPress admin. Google Site Kit gave them traffic stats, Search Console data, and Analytics — all surfaced in a UI they knew. Ripping that away and telling them "just use Google Analytics directly" is a workflow regression, not an upgrade. The pivot here was building a lightweight admin dashboard as part of the Next.js project — not a full replacement for Site Kit, but a mirror of the metrics they actually checked daily: Page views

10 Prompt Patterns I Use Every Single Day Last Tuesday I spent 40 minutes arguing with Claude about a database schema before I realized I had never told it what I already tried. I described the problem, it gave me the same three suggestions I had already ruled out, I pushed back, it apologized and gave me variations of the same three suggestions. The entire session was garbage because I started from zero instead of from where I actually was. I closed the tab, rewrote my first message, and had a working solution in six minutes. That gap — between how most people prompt and how it actually works when you treat the model like a collaborator who needs real context — is what this post is about. Pattern 1 & 2: Lead With What You Already Tried, and State the Constraint That Binds You These two patterns are almost always used together, so I won't pretend they're separate. When you describe a problem without the history of your attempts, you are forcing the model to rediscover your dead ends. Every developer knows this frustration: you explain a bug, get back a solution you tried on Monday, explain you tried that, get a variation, explain that too — it's a recursive waste. The fix is brutal honesty upfront: "I need X. I already tried A and B. A failed because [specific reason]. B is off the table because [constraint]. Don't suggest either." The constraint layer is the other half. Models are optimists by default. They will give you the architecturally clean, perfectly testable solution that requires three new dependencies and a refactor of your auth layer. Unless you tell them you are shipping in two days, can't add dependencies, and the code needs to be readable by someone who last touched Python in 2019. Constraints aren't limitations on the answer — they are the answer. Front-load them or you will spend the session rejecting suggestions that are technically correct but situationally useless. Pattern 3 & 4: Output First, Reasoning After — and Diff Only, Not Rewrites Two sid

One AI gateway with built-in observability and evals Discussion | Link