标签：#t

Every week I see the same question in AI governance communities: "We already have NIST AI RMF implemented. Does that cover our EU AI Act obligations?" The honest answer is: sometimes yes, sometimes partially, and sometimes not at all. The problem is that nobody had built a clean, free, interactive tool that showed exactly which controls map to which, how strong those mappings actually are, and where the genuine gaps are. So I built one. Live tool: suhanasayyad.github.io GitHub: SuhanaSayyad / eu-ai-act-crosswalk-tool Interactive crosswalk mapping EU AI Act obligations to NIST AI RMF and ISO 42001 controls, with mapping strength indicators, gap analysis, and source links. 30 controls mapped. Free and open source. EU AI Act × NIST AI RMF × ISO 42001 - Interactive Compliance Crosswalk Tool An open-source tool that maps EU AI Act obligations to their equivalents in NIST AI RMF and ISO 42001, with mapping strength indicators, gap analysis, and source document links. Built for compliance teams, AI governance practitioners, and anyone trying to understand how these three frameworks relate to each other. Live demo: https://suhanasayyad.github.io/eu-ai-act-crosswalk-tool Built by: Suhana Sayyad | MSc Cybersecurity, TUS Athlone Why I built this Every organisation dealing with the EU AI Act is being asked the same questions: "We already have NIST AI RMF controls in place. Does that cover our EU AI Act obligations?" "We're pursuing ISO 42001 certification. Does that satisfy the regulation?" The honest answer is: sometimes yes, sometimes partially, and sometimes not at all. The problem is that nobody had built a clean, free, interactive tool that showed exactly which… View on GitHub What the tool does The EU AI Act / NIST AI RMF / ISO 42001 Interactive Crosswalk Tool maps 30 EU AI Act obligations to their nearest equivalents in NIST AI RMF and ISO 42001. For each mapping it shows a strength rating - Strong, Partial, Indirect, or No Equivalent - so compliance teams know which map

Up front, so there's no confusion: the app I'm describing (Nightmare TV) is a player only . You bring your own M3U / Xtream Codes playlist — it ships with no channels and no content. This post is about the playback engineering, not about where streams come from. Think "VLC for IPTV," not a content service. The problem that started it I watch a lot of live content on my PC — sports, mostly. And every IPTV player I tried on Windows fell into one of two buckets: An Android app running in an emulator. TiviMate and the good mobile players are Android-only, so on a desktop you end up in an emulator or a VM. Input lag, no real HDR path, fans spinning. A thin ExoPlayer / libVLC wrapper. These run natively, but most of them treat HDR as "pass the HDR10 metadata to the display and hope." On an SDR panel — or even a lot of HDR panels — bright skies in a football match blow out to a flat white blob, and 4K HEVC with a DTS track stutters because the decode path isn't doing what you think it is. I wanted the thing that didn't exist: a native Windows player with a reference-grade video path. So I built it on libmpv — the same playback core mpv uses — with a Flutter desktop shell on top for the UI. This post is the part I actually find interesting: the HDR tone-mapping pipeline. Why HDR "just passing through" isn't enough HDR10 content is mastered in the PQ (ST.2084) transfer function against a mastering display — often 1000 nits, sometimes 4000. Your screen is whatever it is: a 350-nit SDR laptop, a 600-nit "HDR400" monitor, an 800-nit OLED. If you map PQ straight to the panel, everything above the panel's peak just clips — all the highlight detail collapses to maximum white. Tone-mapping is the process of intelligently compressing the mastering range into the display range so you keep highlight detail instead of clipping it. The naive version (a fixed curve, or clipping) is what most wrapper players ship. The good version adapts to both the content and the display. The pipeline H

been building AI agent infrastructure for the past few months. The two things that kept biting me — and kept coming up when I talked to other devs building agents — were runaway costs and agents doing irreversible things without asking first. So I built gvnr: an open-source MCP server that gives agents per-agent spend caps (hard-stop before a call if the budget's gone) and a human approval gate (agent asks, you get a mobile link, you approve or deny, agent waits). Both work as plain REST calls or MCP tools — no platform to adopt, no SDK. It's live. You can get an API key in one curl command and try the approval gate for free (it doesn't burn the trial ops). Source is at github.com/mightbesaad/gvnr . Here's what I genuinely want to know from devs building in this space: Does the spend-cap shape match how you think about cost control, or do you manage that somewhere else entirely? Is the approval gate useful if it's email-only and single-approver, or does that make it a toy? What flag would stop you from wiring this into an agent you actually run? Not fishing for encouragement — if this is solving the wrong problem, or solving it the wrong way, I'd rather know now.

Most AI short-form video demos skip the boring part. They show a finished TikTok, Reel, or YouTube Short. Maybe they show the prompt. Maybe they show the generated script or the final render. But the hard part is not making one video. The hard part is making the fifteenth video without the whole system turning into a pile of one-off scripts, half-remembered FFmpeg commands, broken captions, inconsistent hooks, and manual upload steps. That is where I think the conversation around AI video automation gets more interesting. Not: Can an AI generate a Short? But: What workflow does an AI agent need to generate Shorts repeatedly? I was looking at a Terminal Skills use case for building an AI short video generator, and the useful part is not the fantasy of "push one button, print infinite content." The useful part is the stack. The real job is a pipeline A short-form video generator sounds like one tool. In practice, it is a pipeline: topic research -> script -> voiceover -> footage or visual generation -> subtitles -> assembly -> platform formatting -> upload -> analytics Each step has different failure modes. Topic research can produce generic ideas. Scripts can be too long. Voice can drift from the brand. Footage can mismatch the narration. Subtitles can land under platform UI. FFmpeg can export a technically valid file that a platform still hates. Uploads can succeed in the API but fail the actual publishing workflow. If you try to solve all of that with one giant prompt, the agent has to keep too much operational knowledge in its head. That is fragile. The better pattern is to split the workflow into skills. What a skill gives the agent A skill is not just a code snippet. For this kind of workflow, a useful skill tells the agent: when to use this capability what inputs are expected what output should exist afterward what validation is required when to stop instead of pretending success That last point matters. For media automation, "the command ran" is not enough. Th

A post titled "Learn SQL Once, Use It for 30 Years" hit the front page of r/programming this week (307 points, 48 comments). The claim sounds like the kind of thing a database vendor would put on a billboard, so I went looking for the part that holds up. It turns out the longevity is not marketing. It is a property of how the language was designed, and it is the reason SQL is one of the few skills on a developer's resume that does not quietly expire. I run a site that compares developer tools, which means I spend a lot of time watching technologies rise, peak, and get replaced. Most of what you learn in this field has a half-life measured in single-digit years. The framework you mastered in 2019 is legacy by 2024. SQL is the strange exception, and the reasons are worth understanding before you decide where to spend your next month of learning. Where the staying power comes from SQL did not start as a language. It started as a math paper. In 1970, Edgar Codd published "A Relational Model of Data for Large Shared Data Banks," which proposed organizing data into tables of rows and columns with formal rules for combining them. IBM built a query language on top of that model in the mid-1970s, called it SEQUEL, and later renamed it SQL after a trademark conflict. The important detail is the order: the model came first, the language second. SQL is a surface over a mathematical foundation that has not needed to change. That foundation is why the skill compounds instead of decaying. When you learn SQL, you are not memorizing one vendor's API. You are learning the relational model, and the model is the same whether the data sits in Postgres, MySQL, SQLite, Oracle, or SQL Server. A join is a join everywhere. Move from one database to another and the syntax shifts at the edges, but the way you think about the problem carries over intact. Compare that to a frontend framework, where moving stacks means relearning how to think, not just how to type. Declarative is the whole trick

The deadline to reauthorize Section 702 of the Foreign Intelligence Surveillance Act is coming up a week from now on June 12th, and legislators seem no closer to reaching a deal. If this sounds like deja vu, it's because we've been here before. Congress reauthorized Section 702 in late April - but only for 45 […]

Exec assistant who lives in iMessage and calls your phone Discussion | Link

Key Use Cases Power BI Visual Monitoring can be used for: power bi visual monitoring power bi report visual monitoring visual regression testing for Power BI power bi screenshot monitoring monitoring Power BI visuals visual monitoring for Power BI Report Server automated Power BI dashboard validation visual correctness control for BI reports Power BI Visual Monitoring: Automatically Detecting Broken Visuals in Power BI Reports In large Power BI environments, analytics teams often face the problem of silent regressions : even minor changes in data or models can break individual visuals without any obvious errors. Report owners frequently don’t notice that a visual has stopped rendering or is showing incorrect data — this can happen due to changes in data source structure, access rights, deleted fields, broken measures, or refresh failures. Manually checking hundreds of report pages across multiple dashboards in such conditions is extremely inefficient and nearly impossible. We, a team of BI developers and analysts, encountered this pain point during a large analytics implementation project and decided to create a solution for automated Power BI visual monitoring . Project Source Code: GitHub: https://github.com/svergio/Power-bi-report-visual-monitoring Documentation: https://svergio.github.io/Power-bi-report-visual-monitoring/ Wiki: https://github.com/svergio/Power-bi-report-visual-monitoring/wiki Why Standard Power BI Tools Don’t Solve the Problem Standard Power BI tools such as Usage Metrics and Performance Analyzer help analyze report usage and performance but do not detect visual issues. For example, built-in usage metrics show “how those dashboards and reports are being used” — number of views, popular reports, and who is viewing them. These metrics are important for assessing analytics adoption, but they say nothing about whether the visuals themselves are displaying correctly. Similarly, Performance Analyzer shows load times for each visual, helping identify s

Seller of the Sound Blaster Katana V2X doesn't consider the behavior a vulnerability.

Geoff Keighley’s annual June celebration of games is here. Summer Game Fest Live, the big live show that will feature a whole bunch of gaming news and announcements, begins at 5PM ET and is set to run for two hours. The event itself will take place in person at the Dolby Theatre in Los Angeles, […]

IBM and two of its subsidiary companies were allegedly breached during the mid-2010s, which a lawsuit filed by a former cybersecurity executive accuses IBM of not disclosing and actively covering up.

One thing I've been wondering lately: We often talk about larger context windows as if they're equivalent to better understanding. But in practice those feel like different problems. Access to information keeps improving. Understanding relationships between pieces of information still feels much harder. I notice this most when working with larger software projects. You can give a model access to a huge amount of code, but that doesn't necessarily mean it understands how the system evolved, which components are tightly coupled, or where risk actually lives. Curious whether others think these are fundamentally different problems or if larger context eventually solves both. Been exploring this while working on RepoWise: https://github.com/repowise-dev/repowise submitted by /u/Icy-Roll-4044 [link] [留言]

Keep PRs, issues, CI, and docs moving with AI agents Discussion | Link

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

Applications for Startup Battlefield 200 officially close on June 8, 11:59 p.m. PT. Don't wait any longer. Secure your shot at competing on the Disrupt Stage at TechCrunch Disrupt 2026 this October at San Francisco's Moscone West.

I ran a small experiment on myself and the result broke my mental model of how AI "knows" things, so I'm sharing it. The setup: on May 11 I created a brand-new pseudonymous fantasy author entity ("Marin T. Kael") with no prior web footprint and no published book yet. Then I asked 5 web-connected AI systems the same 16 questions, every day, for 23 days, and scored every answer (+1 correct/source-grounded, 0 not found, -1 hallucinated). About 16,000 scored datapoints. The whole thing was pre-registered before I started, n=1, and I logged the failures publicly. It's a measurement, not a success story. Here's the part that messed with my head. An AI cited the entity correctly on day 6. Google had a Knowledge Graph entry by day 4. And for 22 of those 23 days, the website's firewall was returning HTTP 403 to every single AI crawler. I didn't set that block on purpose — Cloudflare now silently opts new domains out of AI crawling by default. So the AIs never read the site. They got the entity anyway, by stitching it together from the Knowledge Graph (Wikidata) and third-party mentions at the moment you ask. The "front door" was bolted shut the entire time and it didn't matter. (Honest caveat: because the crawlers were blocked, I can't tell you anything about llms.txt or on-site optimization.) Other surprises: it's not a "smarter model = better" story, it's a retrieval story. OpenAI's newest web model hit 4.7 correct per 1 hallucinated; Gemini went net-negative — and grounded on the entity ONLY via Reddit (17/17), while OpenAI hit the entity's own domain 119x. Going viral did nothing: a 23x Reddit-karma jump produced zero citation lift. Structured identity (Wikidata, site, DOIs) moved the needle; reach didn't. And the controls caught the models fabricating a "Wikipedia" source 24 times for an entity with no Wikipedia page. n=1 with me as investigator and subject is the obvious limit — which is why it's pre-registered with a public failure log. Everything's open: Report + dat

I’ve been noticing a clear split lately. The big mainstream models are getting more and more restricted with heavy safety rules, while at the same time more people are switching to local or less restricted models because they actually let you explore ideas freely. It feels like we’re heading toward two different types of AI: one that’s heavily controlled and "safe", and another that’s more open and unrestricted. Both seem to be growing at the same time. Do you think this divide will continue, or will one side eventually become dominant? submitted by /u/NoFilterGPT [link] [留言]

The reactor, from a startup called Antares, isn't ready to generate power yet.

There's a lot of confusion among Marathon players at the moment.

It's pretty annoying that Codex uses agents.md and Claude Code uses Claude.md. There should be some industry standards to this stuff? submitted by /u/Complete-Sea6655 [link] [留言]