AI 资讯

Hi everyone, If you have purchased (at least one) GPU(s) for ML/DL studies and research: How is your experience and is it worth it? What do you use it for and how is the ROI? I have a MacBook Pro with M4 from some years ago, while MPS is useful in many occasions, it's no substitute for a NVDA GPU with CUDA support. So recently I am considering getting a 5060 Ti 16GB , but a GPU cannot run itself, so I then also need to buy other parts (e.g., CPU, RAM, SSD, motherboard, and so on...), which has been getting more expensive lately, especially the RAM. Since I'm still in job-seeking mode, I will mostly use it for learning DL, RL, and LLM-related things and local experiments (e.g., Stanford CS336), or low-level ones like GPU kernel programming and so on. Do you think a local physical GPU would help, or in my case a cloud service like Modal would suffice? Many thanks! submitted by /u/hedgehog0 [link] [留言]

The popular fitness-tracking platform, Strava, is restricting access to its API as part of efforts to clamp down on AI scraping, as reported earlier by TechCrunch. Developers who want to build an app using Strava's data now need to pay for a flat $11.99 / month subscription. In an update on its developer hub, Strava […]

submitted by /u/loosedolphin [link] [留言]

BadHost is a high-severity authentication bypass vulnerability in the widely used Python web framework Starlette, with 325 million weekly downloads. The flaw allows attackers to use malformed HTTP Host headers to bypass path-based access controls and access sensitive AI agent infrastructure, among other systems. By Sergio De Simone

submitted by /u/vox [link] [留言]

Hey Reddit, I just published a study analyzing 25,500 LLM resume evaluations to measure hiring bias. By swapping minor identity and demographic variables on the exact same work history across 10 different models, an independent AI auditor flagged a staggering 45% bias rate driven by "silent bias." Instead of saying anything overtly offensive, models invent professional-sounding excuses to penalize candidates, like when a model dropped its score after I changed the university to MIT, suddenly claiming the candidate's experience wasn't relevant despite praising that exact same experience on the baseline resume. We also found a massive 6x difference in stability between systems, with Qwen and older Gemini models being highly volatile, while the Claude models, Mistral-Large, and Llama 4 proved to be the most stable and fair. Ultimately, AI screening tools are outputting highly subjective, unpredictable opinions driven by statistical noise rather than objective truth, making them a massive liability under regulations like the EU AI Act. You can read the full write-up and explore our interactive data app here: https://re-cinq.com/blog/ai-hiring-bias-25500-llm-evaluations submitted by /u/Signal_Rabbit_8303 [link] [留言]

submitted by /u/ThereWas [link] [留言]

Crescent Island is an air-cooled chip that uses LPDDR5 memory.

Prela is an embedded query language based on Tarski's Algebra of Relations. Its queries are concise, clear, and fast. It is implemented by shallow embedding in a host programming language: Prela operators are regular functions in the host. The implementation follows continuation-passing style which compiles to efficient columnar execution.

Cold email infrastructure on autopilot without Gsuite Discussion | Link

Hey HN, we’re Ismaeel, Eren, Yafet and Nikodem. We built Expanse ( https://expanse.sh/ ) to increase the effective capacity of your HPC/GPU clusters running schedulers/orchestrators like Kubernetes and SLURM. We read the source code, job submission script, and the hardware a workload is about to run on to predict what the job actually needs before the cluster sees it. We also flag failures we think are about to happen and surface line-level optimisations the researcher can apply themselves. The

When I decided to ship this blog in four languages, I had a clear mental ranking. English would win on volume. Spanish would be runner-up because of the sheer speaker count. Japanese would stay steady because it's my native language. Portuguese, I figured, was the long tail. I added it mostly out of completism. Twenty-two days later, the GA4 snapshot disagrees with every part of that ranking. PT: 748 pageviews , 709 sessions EN: 195 pageviews , 176 sessions JA: 27 pageviews , 29 sessions ES: 7 pageviews , 7 sessions That is Portuguese pulling roughly 3.8× English, 28× Japanese, and 107× Spanish on the same blog, same publishing cadence, same author. One Portuguese article on its own (a post about a 24-hour security agent: 375 PV) got more pageviews than my entire English blog combined. I wrote that article hoping Spanish would surprise me. Instead Portuguese surprised me, and Spanish quietly continued to not exist. The setup, so you can discount my numbers properly This is not a clean comparative experiment. It's a single blog, kenimoto.dev , running four language directories ( /en/ , /ja/ , /pt/ , /es/ ). Articles get translated through a cross-language LLM pipeline, then hand-edited for register and locale (BR Portuguese vs PT Portuguese, LatAm-neutral Spanish vs Spain Spanish). The window: 2026-04-30 to 2026-05-21, 22 daily snapshots. EN has 26 articles. JA has 25. PT has 17. ES has 10. So PT has fewer articles than EN and still beats it almost 4 to 1. If you stop reading here, take this one thing: language asymmetry can swallow article-count asymmetry whole . Adding articles in a saturated language is slower than adding articles in an underserved one. Why Portuguese pulled ahead I don't think the answer is "Portuguese readers like me more." I think three asymmetries are stacking on top of each other. 1. TabNews is a community door English doesn't have TabNews is a Brazilian developer community where you can post a technical article and have it actually read by h

There is a special kind of productivity theater that happens during a developer job search. You wake up motivated, open LinkedIn, and apply to 27 positions before breakfast. You press the Easy Apply button with the precision of a professional gamer. By the end of the week, you have submitted 143 applications, updated a spreadsheet with several impressive numbers, and developed a minor emotional dependency on refreshing your inbox. Unfortunately, your inbox still looks like an abandoned shopping mall. No interviews. No useful feedback. No clear explanation. Perhaps two automated emails thanking you for your interest before informing you that the company decided to “move forward with other candidates,” a sentence that has become the corporate version of disappearing into the fog. So you decide to solve the problem by applying to another 200 jobs. This is not a strategy. It is email-based agriculture. You are throwing resumes into the soil and waiting for a recruiter to grow. Volume Matters. Blind Volume Does Not. Let us begin with an uncomfortable truth: getting your first developer job usually requires applications. Sometimes it requires many applications. The market will not discover your GitHub profile through divine intervention. A recruiter is unlikely to wake up in the middle of the night with a mysterious urge to search for junior developers who recently deployed a to-do list. You need to put yourself in front of companies consistently. However, there is a significant difference between applying consistently while improving your positioning and clicking every blue button on LinkedIn until one of you collapses. Volume is useful when it generates information. Blind volume only produces exhaustion. If you apply to 300 jobs with the same generic resume, the same generic portfolio, and the same vague explanation of your skills, you are not running 300 experiments. You are repeating the same experiment 300 times and acting surprised when the result remains unchanged.

The loop I didn't notice closing Seven weeks ago I started using AI for work. Two weeks after that, I published an article. Seven weeks after that — today — the article is one of sixteen, and they are all in a memory file that the AI reads at the start of every new conversation. I didn't notice the loop until I named it. This is a note about that loop, what it is, what it isn't, and why I keep publishing even though the loop doesn't strictly need me to. The shape It runs like this: I decide what to do. I work it out with the AI — usually in dialogue, sometimes by pasting raw code or data. The dialogue becomes a record. Sometimes a memory entry. Sometimes a published article. The record becomes context for the next conversation, which informs the next decision. It didn't look this clean while it was happening. The numbering is hindsight. From inside, the steps overlap. The first step is the one I keep. Direction is mine: what to build, what to write, what to negotiate. The history that shapes those decisions — twenty-four years of solo work, my company, my family, my health — is also mine. The AI is not setting direction. The second step is where most of the leverage is. I describe what I want to do as completely as I can, sometimes by handing over source code. Then I ask: does this look right? Is there a path I'm missing? Where would this break? I'm opening drawers — possibilities I half-saw in my own head — and checking which ones open cleanly. When one opens cleanly, that is the GO signal. Not "will this succeed" but "this is doable, so do it." The third step happens almost without effort. The conversation already exists as text. Some of it becomes a memory entry I add deliberately. Some of it becomes raw material for an article. The article writes itself partly because I have already explained the thing to the AI. The fourth step is the one that took longest to arrive — and the one I want to be most careful about describing. Three phases, not one The loop didn't

An LLM-written kernel benchmarked 38% faster on a microbench. Here is what kernel-level validation showed it actually did at runtime. TL;DR Multi-agent LLMs are now writing CUDA kernels (RightNow AI’s AutoKernel, Meta’s KernelEvolve, a multi-agent system claiming 38% speedup on Blackwell). Source-level benchmarks measure clean throughput on a single isolated kernel. They do not measure SM occupancy under co-scheduling, DRAM bandwidth saturation, dispatcher off-CPU during a real serving workload, or NCCL wait correlation with sibling kernels. Kernel-level validation closes that gap: an eBPF trace of the same kernel running under the same workload as production answers all four questions in one capture. The kernel-writing wave Three pieces of work in April surfaced the same pattern: agents generate CUDA kernels, then quote a single throughput number against a baseline. RightNow AI’s AutoKernel (announced Apr 6) – LLM agents iteratively rewrite CUDA kernels for a target metric, claiming substantial speedups on selected microbenchmarks. Meta’s KernelEvolve – similar shape: agents propose kernel variants, rank by throughput, keep the best. Multi-agent system on Blackwell (Apr 29 reports) – claims a 38% speedup on a public kernel benchmark using a coordinated agent setup. All three are real research, all three produce real kernels, and all three report numbers that come from microbenchmarks. The microbench setup is exactly what you want for the optimization loop. It is not what you get in production. What microbenchmarks do not see Run an LLM-generated kernel under nvprof or nsight-compute on an otherwise-idle GPU and the throughput number is real. Put the same kernel in front of a vLLM serving workload and four properties change immediately: SM occupancy under co-scheduling. The kernel that achieves 95% SM occupancy in isolation will achieve 40-50% with three other kernels sharing the same SMs. The optimizer never sees this regime. DRAM bandwidth saturation. A kernel tha

AI agents are getting smarter fast. They can reason through tasks, manage workflows, call tools, and automate decisions across applications. But as these systems become more capable, one challenge becomes impossible to ignore: reliability. How do you know your AI agent is making the right decisions consistently? How do you test workflows that involve memory, reasoning, and multiple execution steps? And how do you debug failures when outputs become unpredictable? That’s exactly what this free live webinar, “ Testing AI Agents in Python: Building Reliable Evals with LangGraph & LangSmith ,” is focused on. The session includes a “ Live demo of the AI agent evaluation pipeline ,” where you’ll see how developers are building structured evaluation workflows using LangGraph and LangSmith to test, trace, and improve AI agent performance in real-world scenarios. Here is the link to register .. Who Should Join This Session? This webinar is designed for developers and technical teams working with AI systems, especially: Python developers building AI agents or LLM workflows AI engineers exploring evaluation and observability Architects designing production-ready AI systems Product teams experimenting with AI automation Founders building intelligent applications faster Whether you’re actively deploying AI agents or still evaluating the ecosystem, this session will give you a clearer understanding of how reliable AI systems are actually built. What You’ll Learn During the Webinar This isn’t a high-level AI trends session. The focus is practical implementation, testing workflows, and evaluation strategies developers can actually use. In this webinar, you’ll learn: Why evaluation matters for modern AI agents How LangGraph helps manage complex agent workflows How LangSmith can trace and monitor agent execution Ways to create repeatable and scalable evaluation pipelines Practical approaches for debugging and improving AI agent behavior See the AI Evaluation Pipeline Live One of the b