AI Health Companion for Chronic Illness Discussion | Link

Prerequisites (what you need before starting) Account and tokens : user:MODDER credentials and access to the proposal inbox. Local tools installed : qemu-system-x86_64 , libfuzzer or afl++ , boofuzz (optional), openssl , jq , base64 . Artifact store access : S3 or equivalent with write permissions. HSM access for owner : owner HSM is required only for final autonomy=1 apply; Modder does not sign. Test harness : test-harness CLI that runs vectors (provided by platform). If not present, use the included run-vectors.sh wrappers. Network : ability to reach staging Overcrest endpoint and Zclarity3D collector. Basic skills : copy/paste, editing JSON, running shell commands. submitted by /u/GabenHood [link] [留言]

Quick share of something I built recently. I've been working on a SaaS product and along the way kept needing small utilities for myself: QR codes, UTM links, OG tag previews, schema markup, robots.txt, sitemap, base64/URL encoders, etc. Every site I found for these either required an account, was buried in ads, or made me wonder where my data was going. So I built clean versions and put them at reslug.com/tools . All free. No account. The interesting bit: every tool runs entirely client-side. The QR code generator never sends your WiFi password to a server. The UTM builder never logs your URLs. The schema generator outputs locally. The redirect checker is the only exception, since CORS forces a server proxy for that one (and it doesn't log the URLs it checks). Stack for the free tools: React 19 + Vite + TypeScript + Tailwind, qrcode library for QR generation, all rendered as pure components. Main product behind it is .NET 9 + Postgres but you'd never hit that from /tools. Why I'm posting: curious what's missing. I've got about 27 more tools planned but I'd rather build what people actually need. Also genuinely interested if anyone has feedback on the UI/UX - I rebuilt the hero last week and I'm not 100% sure it's better. https://reslug.com/tools submitted by /u/ervistrupja [link] [留言]

Startup Battlefield applications are due tomorrow, so now's the time to put the finishing touches on your submission!

We take the Falcon 9 rocket for granted. But we probably shouldn't.

Been building an AI-heavy app for a few months. No visibility into what our AI API calls were actually costing until the Anthropic bill arrived. So I built a GitHub Action that scans for AI usage on every PR and posts a cost analysis comment automatically. First thing it caught in our own codebase: server/services/divergence-detector.js was using claude-sonnet-4-6 with max_tokens=150 to generate 2-sentence explanations. Sonnet costs $15/M output tokens. Haiku costs $4/M. For a 2-sentence output there is zero quality difference. We were paying 3.75x more on every single call and nobody noticed. What it posts on every PR: 💰 Cost delta vs base branch ( "this PR adds +$44/month" ) ⚠️ Warnings for expensive model misuse with specific fix recommendations 🔁 Duplicate AI call patterns that should share a service layer 🔄 Missing retry/backoff logic that will crash under rate limits 💡 Prompt caching opportunities (up to 90% input cost reduction) Supports: Languages: JS, TS, JSX, TSX Providers: Anthropic · OpenAI · Google Gemini · AWS Bedrock · LangChain Zero dependencies · Free Add it to any repo in 2 minutes: - uses: kavyarani7/ai-arch-scanner@v1 with: github_token: ${{ secrets.GITHUB_TOKEN }} threshold: '500' 🔗 GitHub Marketplace 🔗 Repo Happy to answer questions about how it works or what patterns it detects. submitted by /u/Upbeat_Will_3342 [link] [留言]

More dogs!

GitHub热门项目 | Skills for Design Engineers | Stars: 2,102 | 258 stars today | 语言: TypeScript

Hi r/MachineLearning , Wanted to share something I'm excited about. I’ve been fascinated by AlphaEvolve and its results for more than a year now, but using open source frameworks seems overwhelming because of the high costs. I can’t really afford hundreds of Claude Opus calls every time I want to run it. I want to be able to try it out many times and all sorts of unique domains. What if it was possible for AlphaEvolve to be much more affordable while getting a better performance? Over the last six months or so, I’ve been working on LEVI, an open source AlphaEvolve-like system that can outperform existing open source frameworks at a fraction of the cost (upto 35x cheaper!). It can also run on Claude Code or Codex, making it even more accessible (I've mostly been using it with a QWEN-30B). LEVI comes in two flavors where I felt it’ll make the most difference: Code Optimization, and Prompt Optimization (sorry math, you got a less direct path; workable through the code route). The core thesis behind LEVI is that with the right search architecture, smaller models can substitute for or outperform larger ones. This means it’s much more economical to rely on smaller models for most of the work. That’s the entire takeaway. Making this work in practice is a different problem, but if you forget everything else from this post this is the only message I think I’m really trying to convey here. LEVI does it in three ways: 1) Invest in solution diversity from the start and ensure its maintained. We don’t want to converge to the same solution, especially with smaller models in the mix, and rely on large models to pull us out of the basin. 2) Use smarter routing across larger and smaller models (i.e. most mutations don’t require a Claude Opus X) 3) For prompt optimization not every rollout is as important. Build a proxy subset to approximate. I’ve tried LEVI on systems problems (like MoE scheduling or database transaction scheduling) and found that LEVI outperforms existing framework

With Father's Day on the horizon, happening June 21st, it's time to start thinking about what kind of gifts you want to buy for the fathers you care about. You know your dad best - he may be a man of simple pleasures who wants nothing more than to share a meal or drinks with […]

Google is rolling out "across the board" updates to NotebookLM. The AI-powered note-taking app now uses Google's upgraded Gemini 3.5 model, which will allow it to respond with "more accurate and reliable information," according to a blog post on Monday. Launched in 2023, NotebookLM allows you to interact with your notes and sources using AI, […]

Apple’s annual WWDC event is kicking off on June 8th with a keynote presentation starting at 1PM ET / 10AM PT, where Apple will announce major updates to iOS, macOS, and its other operating systems. Among those updates could be Apple’s delayed Siri overhaul, which has faced setbacks since it was initially announced at WWDC […]

In the summer of 2016, Pokémon GO launched to a user base roughly fifty times larger than its capacity planning had anticipated. The engineering team had done load testing. They had throughput thresholds. They had autoscaling configured. Within hours of launch, the service was degraded globally — not because the infrastructure could not scale, but because it scaled too slowly against an arrival rate that exceeded every modelled scenario, and because the metric that was driving scaling decisions (CPU utilisation) lagged behind the actual saturation signal by several minutes. By the time CPU registered critical, the request queue had already grown to the point where p99 latency had crossed into the range where users were abandoning sessions faster than new sessions were being created. The engineering post-mortem identified the same root cause that appears in the post-mortems of most capacity-related incidents: the organisation's operational metrics were measuring how hard the infrastructure was working, not how much work the service could safely accept. CPU percentage is a resource utilisation metric. Memory percentage is a resource utilisation metric. IOPS is a resource utilisation metric. None of them is a service throughput metric. None of them tells you, with precision, at what arrival rate your SLO begins to degrade. Safe Operating Throughput is that metric. It is not a new concept in queueing theory or systems engineering — the idea of a safe operating ceiling predates modern distributed systems. What is new is its treatment as a first-class SRE metric: formally derived from load test data and SLO targets, continuously monitored for drift, and operationally enforced as a constraint in autoscaling configuration, capacity planning decisions, and deployment pipeline gates. Why Existing Capacity Metrics Are Insufficient The canonical capacity management approach in most organisations works like this: observe CPU or memory utilisation, set an autoscaling threshold (t

Find the answers to some of the most common GitHub-related questions. The post GitHub for Beginners: Answers to some common questions appeared first on The GitHub Blog .

Google is making Gemini 3.5 the default model in NotebookLM

We've all been there. Your first encounter with authorization looks something like this: if ( user . role === " ADMIN " ) { // allow access } It works. It's simple. It ships fast. And then, three months later, your application has grown, requirements have shifted, and you're staring at a codebase where authorization logic is scattered everywhere—APIs, services, UI components—like a puzzle that nobody remembers how to solve. The truth is: this approach doesn't scale. Not because it's inherently flawed, but because it conflates two very different concepts that should never be mixed. The Core Mistake: Confusing Identity with Capability Here's the problem we're actually trying to solve. As your application grows, you inevitably end up writing code like this: if ( user . role === " BRANCH_MANAGER " || user . role === " SYSTEM_ADMIN " ) { // allow access } Then a stakeholder asks: Can we create a hybrid role? Or: We need Auditors who can export reports but not edit records. And suddenly your role logic explodes into an unmaintainable mess. The fix isn't adding more conditions. The fix is understanding that roles and permissions answer fundamentally different questions. Roles Define Identity Roles are categories of users. Examples: SYSTEM_ADMIN CLIENT BRANCH_MANAGER AUDITOR Roles answer: Who is this user? They establish high-level authorization boundaries. Examples: Staff Portal vs Customer Portal Internal Admin Area vs Public Application Employee Features vs Client Features Think of roles as identity labels . Permissions Define Capability Permissions represent atomic actions. Examples: LOAN_APPROVE USER_DELETE REPORT_EXPORT ACCOUNT_EDIT Permissions answer: What can this user actually do? Your application should not constantly ask: What role are you? Instead, it should ask: Do you have permission to perform this action? Because: Users have Roles Roles contain Permissions Code checks Permissions That distinction changes everything. Always Decouple Identity from Capability T

Per-request attribution starts with five fields on every call: provider, model, input tokens, output tokens, and ownership tags such as team, feature, and customer. A monthly vendor bill cannot explain why one feature, one tenant, or one prompt template suddenly became expensive. Request-level math can. As of June 8, 2026, OpenAI lists GPT-5.4 mini at $0.75 per 1M input tokens and $4.50 per 1M output tokens, while Anthropic lists Claude Sonnet 4 at $3 and $15 respectively. Gateway logs are useful, but they rarely solve AI cost tracking per feature unless you enrich them with business context and retry metadata. The practical operating model is simple: calculate cost on every request, attach ownership dimensions, then roll the data up into team, feature, and customer views. If you are searching for "LLM cost attribution per request," you are usually already past the basic billing problem. You can see your OpenAI or Anthropic invoice, but you cannot answer the questions finance and engineering actually care about: which feature drove the spike, which team owns it, which customers are unprofitable, and which prompt or model change caused the jump. That is why per-request attribution matters. It turns AI spend from a monthly surprise into an operational metric you can act on in the same day. Why LLM cost attribution per request matters now According to the FinOps Foundation's 2025 State of FinOps report, 63% of respondents now manage AI spending, up from 31% the year before. That jump is the real signal. AI cost is no longer a side bucket inside cloud spend. It is becoming a first-class FinOps workload. For teams spending $5,000 to $50,000 per month on LLM APIs, averages break down quickly. A support assistant, an internal coding copilot, and a customer-facing generation feature can all hit the same vendor account while having completely different margins, latency targets, and prompt shapes. If you only look at total spend by provider, you lose the unit economics. Per-r