AI 资讯

OpenAI introduces Patch the Planet, a Daybreak initiative helping open-source maintainers find, validate, and fix vulnerabilities with AI and expert review.

OpenAI introduces new Daybreak tools, including Codex Security and GPT-5.5-Cyber, to help organizations find, validate, and patch vulnerabilities at scale.

Every AI developer has been here: your app is throwing 503s, users are pinging you, and you have 12 browser tabs open — OpenAI status page, Anthropic status page, the GitHub Copilot health page, three different Discord servers — trying to figure out is this me or is it them? That's the problem we set out to solve. Prismix aggregates status from 77 AI services in one place. Six weeks of running it in production taught us some things that might save you time. The problem is worse than you think AI APIs don't fail like traditional infrastructure. They fail in weird, partial ways: Degraded performance that passes your health checks but makes your product feel broken Regional outages — OpenAI US-East is down while EU is fine, so half your users are affected Silent rate-limit cascades — the API returns 429s but their status page says "operational" for another 20 minutes Incident lag — providers often post status updates 10–30 minutes after engineers are already aware The official status pages are optimistic by design. They're customer-facing communications tools, not real-time engineering dashboards. There's nothing wrong with this — but it means you need a different mental model for "is this service down?" What 77 status pages look like in aggregate When you watch 77 AI services simultaneously, patterns emerge fast. OpenAI is the most-watched service (and has the most incidents to watch). The pattern is almost always the same: investigating → identified → monitoring → resolved , typically in 45–90 minutes. The investigating phase is where most developers panic — it looks bad but usually resolves without action on your end. Anthropic runs noticeably clean compared to its API usage growth. Incidents are rarer and shorter. When they do happen, updates arrive faster than most providers. The long tail is interesting. Services like Replicate, Runway, ElevenLabs, and Suno have incident patterns that don't correlate with OpenAI at all. If you're routing across multiple providers

A few days ago I had an idea: what if one LLM could orchestrate other LLMs as agents — not just calling them, but verifying that each agent's output was actually correct before passing it to the next? I work on NeuralBridge (an open-source self-healing SDK for LLM pipelines), so I decided to build it and test it with two real providers: KIMI (Moonshot) and Agnes AI . The Core Problem: Failover ≠ Correctover Most API gateways and LLM routers stop at "HTTP 200" — they retry or switch providers, but they never check if the output is actually correct . # What everyone else does: try : result = call_llm ( prompt ) return result # HTTP 200 = success? 🚩 except Exception : result = call_llm_fallback ( prompt ) return result # Still not verified! This is dangerous. A failover from gpt-4o to gpt-4o-mini might silently drop 3 critical fields. A KIMI response that returns "200 OK" might still be missing key entities. Correctover is the idea that switching providers isn't enough — you must verify semantic equivalence after every switch. The Architecture We built a simple DAG-based chain executor with three key capabilities: DAG orchestration — define multi-step workflows where nodes depend on each other Per-node semantic validation — every LLM output is checked against a Contract before passing to the next node Cross-provider Correctover — if validation fails, automatically retry with a different provider from neuralbridge import SelfHealingEngine , ProviderConfig , Contract from neuralbridge.chain import ChainBuilder engine = SelfHealingEngine ( providers = []) engine . add_provider ( ProviderConfig ( name = " moonshot " , base_url = " https://api.moonshot.cn/v1 " , api_key = " ... " , models = [ " moonshot-v1-8k " , " moonshot-v1-32k " ], )) engine . add_provider ( ProviderConfig ( name = " agnes " , base_url = " https://apihub.agnes-ai.com/v1 " , api_key = " ... " , models = [ " agnes-2.0-flash " ], )) chain = ( ChainBuilder ( engine ) . node ( name = " planner " , system = "

Every World Cup there's a moment. Some player nobody outside their domestic league had heard of scores an absolute screamer in a knockout match, and by the time they've finished celebrating, their follower count is climbing like a rocket. I always found that fascinating, but I could never see it happening. By the time the "X gained 3M followers!" tweets show up, the surge is already over. So this tournament I built a little tracker that snapshots player follower counts on a schedule and shows me the growth curve in near real-time. Here's how it works. The problem with doing this "properly" My first instinct was the official APIs. That died fast. Instagram's Graph API won't give you follower counts for accounts you don't own. TikTok's Research API is academics-only and takes weeks of applications. X's API now starts at $100/month and climbs steeply from there. I just wanted public follower counts — numbers anyone can see by opening the app. I didn't want a data partnership and a legal review. I ended up using the SociaVault API , which wraps public profile data from each platform behind one key. One request, one credit, JSON back. The shared client Everything runs through one tiny helper: // Node 18+ has fetch built in const API_KEY = process . env . SOCIAVAULT_API_KEY ; const BASE = " https://api.sociavault.com " ; async function sv ( path , params ) { const url = new URL ( BASE + path ); Object . entries ( params ). forEach (([ k , v ]) => url . searchParams . set ( k , v )); const res = await fetch ( url , { headers : { " X-API-Key " : API_KEY } }); if ( ! res . ok ) throw new Error ( ` ${ res . status } ${ await res . text ()} ` ); return res . json (); } Grabbing follower counts across platforms Each platform nests the count slightly differently, so I use fallback chains to stay defensive: async function instagramFollowers ( username ) { const data = await sv ( " /v1/scrape/instagram/profile " , { username }); const p = data . data ?. user ?? data . data ?? data

MCP is useful, but most of the time you do not actually need it. It gives an agent a clean way to discover tools, call APIs, and work with external systems. In practice, a skill file can describe the same usage path without dragging the whole MCP surface into context. But MCP is not free; rather than MCP itself, the real issue is the habit of loading a big MCP surface into every session, no matter what the session is actually about. Once a Claude Code or Codex run pulls in a bunch of servers, the model sees those tool definitions right away, even if the job is just writing docs or fixing a small bug. That is where the waste starts. The hidden cost of always-on MCP Every MCP server brings metadata with it: tool names, descriptions, argument schemas, nested parameters, enums, examples, and sometimes prompts or resources. While useful, this is still context. If you connect a handful of lightweight tools, the overhead is annoying but manageable. If you connect a real stack of services, the cost compounds fast. In practice, you end up paying for: tool discovery before the task starts schema text the model may never use repeated loading across unrelated sessions extra context pressure that pushes out the actual work That last point matters more than people think. Context acts as the active working set the model uses to reason. The more of it you burn on static tool catalogs, the less room you have for the user request, the repo state, prior reasoning, and the actual answer. Anthropic has already written about this problem directly in the context of MCP. Their engineering post on code execution with MCP calls out tool-definition bloat and shows how direct tool calls can consume a lot of context before the model even starts doing the real job. The tool list is not just setup noise; it is part of the session cost. Why skills are cheaper Skills take a different path. A skill file keeps the always-loaded portion tiny. Usually that means just the skill name and a short descript

Code reviews, configuration changes, and debugging sessions demand precise understanding of what changed between two versions of text. Manual comparison of large blocks of code or configuration files is error-prone, and version control diffs don’t always provide a quick, focused view for sharing or verifying changes outside a repository. What it is Diff Checker is a browser-based text comparison tool that performs line-by-line analysis of two text blocks and highlights differences with color-coded visual indicators. It processes text entirely in the browser—part of the 200+ free tools on DevTools—meaning no data is uploaded or stored, a privacy‑first design. The interface uses a split‑pane layout: original text on the left, modified text on the right. As you paste or type, the comparison engine recalculates the diff in real time, marking added, removed, and changed segments so differences are immediately clear. Several configuration options tailor the analysis. Toggling whitespace sensitivity ignores differences in indentation or blank lines, useful when comparing code from teams with different formatting conventions. Case sensitivity can be turned off for text where capitalization inconsistencies are irrelevant. A swap button reverses the comparison direction with a single click, handy when the assignment of “original” and “modified” is accidentally reversed. How to use it Paste the original text into the left panel and the modified version into the right panel. The diff view updates instantly, so you don’t need to press a button to see changes. For code, the process is straightforward. Drop a baseline function on the left: function calculateTotal ( items ) { let total = 0 ; for ( let item of items ) { total += item . price ; } return total ; } And the updated version on the right: function calculateTotal ( items , taxRate = 0 ) { let total = 0 ; for ( let item of items ) { total += item . price * ( 1 + taxRate ); } return Math . round ( total * 100 ) / 100 ; } The

Placeholder text is necessary scaffolding in web development, but ubiquitous Lorem ipsum can lead to design monotony and disconnect from project context. Developers building mockups, prototypes, or content-heavy interfaces often need filler text that matches the tone of the target application without introducing distracting Latin. What it is The Lorem Ipsum Generator is a browser-based tool that produces placeholder text in multiple styles, moving beyond classical Latin pseudo-text. It offers distinct variants: traditional Lorem ipsum, Hipster Ipsum with artisanal terminology, Corporate Speak filled with business jargon, and Pirate Ipsum with nautical themes. Each style maintains readability while providing vocabulary that aligns with the spirit of a given project. The generator is part of DevTools, a privacy-first collection of 200+ free browser tools where all processing happens locally—no signup, no tracking. Developers can configure generation parameters to specify the number of paragraphs, total word count, and whether to start with the familiar “Lorem ipsum dolor sit amet” opening. The output is plain text ready for pasting into HTML, design files, or CMS entries. How to use it The interface is a straightforward form: select a text style from the dropdown, then set the number of paragraphs or words you need. The tool generates the text instantly and provides a one-click copy button. <!-- Example output structure when pasting into HTML --> <div class= "content-area" > <p> Leverage agile frameworks to provide a robust synopsis for high level overviews... </p> <p> Iterative approaches to corporate strategy foster collaborative thinking... </p> </div> For typical workflows, 1–3 paragraphs suffice for article previews or body content. Headlines work well with 5–15 words, while navigation elements often need only 2–5 words. The quick copy functionality streamlines populating multiple content areas. Different styles suit different contexts: Corporate Speak makes busi

One Model to Command Them All Discussion | Link

Why AI Alternatives Matter AI is prone to problems affecting its output: hallucinations, incompleteness, inconsistency, and bias. AI usage is costly, and the popular free services might require expensive paid plans or downgrade to sponsored light versions at any time. Don't Hit Submit! Ethical issues aside, lazily using AI to often and too early won't make you a better coder or more creative. And AI companies don't only take your money, they're also after your data – and your time! Techniques like Rubber Duck Debugging (internal dialog development preparing questions and anticipating answers without actually asking anyone) are alternatives to AI for coding and creativity. Don't Ask Suggestive Questions If your question implies a certain answer, asking only makes sense for falsification. AI (and other people) will hopefully tell you when you're completely wrong. Only that AI often doesn't. Current models are trained for flattery and verbosity. Don't Ask Why What a waste of time! Try to ask open questions, and always prefer asking "how", not "why". Stay Skeptical Don't believe anything without a factful proof or a recent, reputable, relevant source. GEO, the AI-agent-targeting variant of search engine optimization, already succeeded to gaslight AI and poison its answers with fake sources biased towards commercial results. AI seems much more gullible than real people. Source: The Shape of Enshittification: Books That No Longer Get Read, An Internet That No Longer Gets Surfed, & The End of Social Media As We Know It.. Principle of Least Power Remember the rule of least power : don't rent a truck when you need a mini van. Don't use AI when you need autocomplete, web search, or a tutorial! I sketched a pyramid of thinking, creativity, and information retrieval again. As you can guess, AI assistants are "on top" as the most costly exception, while the broad basis should be traditional groundwork. Here's a cute AI-slop adaption: Source: Hand-Crafted Creative Counter-Culture

2026 AI Coding Agents Are Making Developers Forget How to Code: Why the Convenience Trap Threatens Innovation As AI‑driven platforms like Atoms, Devin, Windsurf, Cursor, and Warp reshape software engineering, the real cost may be a gradual erosion of core programming fundamentals. The latest MarkTechPost comparison shows AI coding agents moving from novelty to mainstream. Teams report faster feature cycles, fewer lines of manual boilerplate, and a shift toward intent‑first workflows. Yet beneath the productivity headlines lies a subtle trade‑off: every hour spent letting an agent write code is an hour not spent exercising the mental muscles that let us reason about edge cases, optimize performance, or invent novel algorithms. The Rise of Intent‑First Development Modern agents excel at turning a natural‑language description into a runnable diff. Atoms uses multimodal reasoning to interpret UI sketches; Devin can autonomously open pull requests after a high‑level prompt; Windsurf lets engineers edit across files with conversational commands. This paradigm reduces the cognitive load of syntax hunting and lets engineers focus on what the software should do, not how to type it. Measuring the Productivity‑Skill Trade‑off Data from early adopters shows a 38% cut in boilerplate typing and a 22% boost in sprint velocity. However, internal surveys reveal a 15% drop in self‑reported confidence when debugging low‑level concurrency bugs, and a 20% increase in reliance on agent‑generated explanations rather than personal code walkthroughs. The numbers suggest a growing dependency that mirrors the calculator effect seen in mathematics education. Second‑Order Shifts: From Craftsmanship to Orchestration As routine typing fades, engineers spend more time validating AI output, refining prompts, and orchestrating multi‑agent pipelines. Traditional code reviews evolve into “prompt reviews,” where the gatekeeper judges whether the AI captured the business intent. New roles—AI Interaction

From fake tickets to cloned websites, AI is magnifying World Cup scams. Can fans distinguish between what’s real and what’s not?

Build AI agents, workflows, and apps in one stack Discussion | Link

Your payment tests passed in staging. Then PhonePe pushed an SDK update on Tuesday, the UPI intent...

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

Here's something that'll keep you up at night: 67% of World Cup 2026 goals in the 85th+ minute came from teams that were losing at the time . That's significantly higher than the 43% rate we saw in the 70-80 minute window. This single statistic reveals a hidden pattern in how desperation fundamentally rewires attacking strategy when the clock ticks down to the final whistle. As someone who's spent the last three months drowning in World Cup 2026 broadcast data, match statistics, and possession metrics, I've become obsessed with understanding how pressure affects team behavior in those nail-biting final minutes. The conventional wisdom says that late-game goals are chaotic, desperate, and unpredictable. But the data tells a much more interesting story—one about tactical discipline collapsing under psychological weight. The Numbers Behind the Drama Let me walk you through what we found when analyzing 64 matches from the 2026 tournament across 16 days of group stages. Time Period Total Goals Avg. Pass Completion % Shots on Target Defensive Errors 0-30 min 24 82.3% 18 3 30-60 min 31 81.7% 26 5 60-75 min 28 79.4% 24 8 75-85 min 19 76.8% 22 12 85-90 min 18 71.2% 19 18 90+ min (stoppage) 14 68.9% 16 22 Notice the decline? By the 85-90 minute window, pass completion drops to 71.2%—that's an 11-point deterioration from the opening 30 minutes. But here's where it gets weird: defensive errors triple in that same window. Teams aren't just playing sloppily; they're making genuinely catastrophic mistakes. Team-Specific Patterns: The Pressure Responders Not all teams crack under late-game pressure equally. Here's where the real story emerges: Team 85+ Min Goals Scored 85+ Min Goals Conceded Goal Differential Win Rate (Tight Matches) Argentina 6 2 +4 85% France 5 3 +2 72% Brazil 7 4 +3 81% England 3 5 -2 58% USA 4 6 -2 62% Morocco 5 2 +3 79% Japan 2 7 -5 41% What jumps out immediately? Argentina and Brazil are outliers . They scored 13 combined goals in the final 5 minutes but conc

A few months ago I was demoing my RAG-powered support bot to a colleague, feeling pretty confident about it. Then it confidently told her our refund policy was “30 days, no questions asked.” Our actual policy is 14 days, with conditions. The bot didn’t hedge. It didn’t say “I’m not sure.” It just made it up and said it with the same calm tone it uses for everything else. That demo stung. RAG was supposed to fix hallucinations, not just relocate them. Here’s what I learned debugging it, roughly in the order I learned it. 1. My chunks were too big, and too dumb I was splitting documents by character count, 1000 chars with slight overlap. It felt efficient. It wasn’t. A single chunk often contained unrelated sections. For example, the end of a “Shipping Policy” and the start of a “Returns Policy” could sit together in the same block. So when the retriever saw a query about returns, it would grab that chunk and the model would blend both sections into one confident but wrong answer. Fix: I switched to semantic chunking based on headings and paragraphs instead of raw character limits. More work upfront, but it stopped feeding the model Frankenstein context. 2. I trusted top-k similarity way too much My retriever was pulling the top 3 chunks by cosine similarity and passing them straight into the prompt. The problem: “similar” is not the same as “relevant.” A chunk can be semantically close to the query but still not actually contain the answer. The model doesn’t know that, it just assumes everything in context is true. Fix: I added a reranking step using a cross-encoder and started logging retrieval scores properly. That alone made it obvious when the system had no real answer but was still trying to act confident. 3. I never told the model it was allowed to say “I don’t know” My prompt was basically: “Use the context to answer the question.” That’s it. No instruction on what to do when the context is insufficient. So the model did what LLMs do when under-specified: it f