AI 资讯

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

https://preview.redd.it/tj6mb8uzxj6h1.png?width=2336&format=png&auto=webp&s=5576f4c3bcfb905fdc0154b5c45a46316be880dd I asked Apple directly about the current recommended way to guide users through installing a Progressive Web App from Safari on iOS. My question was dismissed. And every other question relating to it was dismissed or hidden after being published. The reason I asked is because the install flow for PWAs on iOS keeps getting harder to explain to normal users. In the latest iOS developer beta, the path appears to be something like: 3 Vertical Lines Share button Scroll down Add to Home Screen There is no obvious install prompt, no clear browser level affordance, and no simple language that maps to what people expect when they hear “install this app.” I understand Apple has its own platform incentives, but this affects real web products. For developers building web-first tools. The frustrating part is not just that the flow is bad. It is that Apple does not seem interested in acknowledging the issue when asked directly. Am I missing something here? How are other web developers handling PWA onboarding on iOS right now? Are you building custom instruction screens? Avoiding PWAs entirely? Sending users to the App Store instead? Or just accepting the drop-off? I attached the screenshot because I think this is worth discussing more publicly. submitted by /u/Jacoby_Broadnax [link] [留言]

"I don't prompt Claude anymore. My job is to write loops." — Boris Cherny, Claude Code creator Though I see where he's coming from, I'd put it differently. A developer's job isn't to write loops. It's to design state machines. Every major agent framework — Claude Code, Codex, Cursor, LangGraph — does the same thing under the hood. A while loop calls an LLM, checks if it wants to use a tool, runs the tool, repeats until done. The loop isn't just a solved problem. It's a boring problem. The hard part is everything around it. A loop has no idea what state the work is in. It just keeps going until something breaks or you run out of tokens. That's the Ralph Loop — named after the Simpsons kid who put a crayon in his nose. Agent, infinite loop, go. The Ralph Loop works, is famous, and has zero memory of where it is in the job. Like Ralph, it keeps going without knowing why. The Fix: A Finite State Machine Think about the NBA Finals. The Spurs and the Knicks aren't improvising — every possession has a state. Fast break. Inbound play. Half court set. Each one has specific reads and triggers for what happens next. Point guard De'Aaron Fox isn't making it up as he goes. The system tells him what situation he's in, and the situation tells him what to do. Your agent works the same way. You define the stages — planning, implementing, reviewing, error handling — and you define what triggers each transition. The agent doesn't orchestrate. It executes. One focused job per state. Why This Matters in Production When agents break, it's almost always one of three things: Infinite loops — one system repeated the same answer 58 times before anyone noticed. Context overflow — the history gets so long the model starts quietly forgetting things. Goal drift — 70 turns in, "don't touch auth" has completely evaporated. State machines fix all three. The loop runs until the list is empty, not until you run out of tokens. The goal lives in the transition logic, not in the context getting squeezed

I built a distributed compute grid where your idle laptop runs ML jobs — the orchestrator behind it The pitch: a single FastAPI hub takes compute jobs from ML researchers, and a fleet of home PCs and gaming rigs (RTX 4090s, M2 MacBooks, anything with a GPU and a Python interpreter) polls in, picks up work, and ships results back. A 20% platform fee funds the hub. An interactive dashboard shows the mesh in real time. I have been living inside this codebase for a few weeks. This post is about the part that actually determines whether the thing works or does not — the orchestrator . No frontend, no marketing — just the brain. Live dashboard: man44.zo.space/compute-pool Repo: github.com/AmSach/ComputePool-Grid The problem with "dumb" schedulers The first version of ComputeOrchestrator had a one-line bug that took down a 12-node stress test. Two jobs hit the hub at the same millisecond. Both saw the same node as idle . Both wrote busy to the same row. One node ended up double-allocated, the other starved, and the test logs looked like a hostage negotiation. The fix had to be three things at once: A scoring function that picks the right node, not just the first idle one. An async lock so concurrent submissions cannot race on a single node. A heartbeat monitor that reclaims nodes that ghosted. Here is what it looks like now. The scoring algorithm def _calculate_score ( self , capacity : Dict [ str , Any ], requirements : Dict [ str , Any ]) -> float : """ Heuristic for node-task matching. """ score = 0.0 if capacity . get ( " gpu_vram " , 0 ) >= requirements . get ( " min_vram " , 0 ): score += 10.0 if capacity . get ( " cpu_cores " , 0 ) >= requirements . get ( " min_cores " , 0 ): score += 5.0 return score The weights are deliberately lopsided. A node that satisfies a job's VRAM requirement gets a 2x bonus over a node that just barely has enough cores. The intuition: GPU work is the long pole. If you cannot fit the model in VRAM, nothing else matters, no matter how many

What is a package? In Go, every Go program is made up of packages. A package is a directory of .go files that share the same package declaration. The primary purpose of packages is to help you isolate and reuse code. myapp/ ├── main.go ← package main └── math/ ├── add.go ← package math └── sub.go ← package math Both add.go and sub.go declare package math. They can call each other's functions directly, no import needed within the same package. Inside a package, every .go file should begin with a package {name} statement which indicates the name of the package that the file is a part of. Every exported identifier (capitalized name) in that directory is accessible to anyone who imports the package. Here's what that looks like in practice: // math/add.go package math // pi is an unexported variable. var pi = 3.14159 // Add returns the sum of two integers. // Exported — starts with a capital letter. func Add ( a , b int ) int { return a + b } // math/sub.go package math // Exported — starts with a capital letter. func Subtract ( a , b int ) int { return a - b } // main.go package main import ( "fmt" "github.com/yourname/myapp/math" ) func main () { fmt . Println ( math . Add ( 3 , 4 )) // 7 fmt . Println ( math . Subtract ( 10 , 3 )) // 7 // fmt.Println(math.pi) — compile error: unexported } Two rules to remember: Capital letter = exported (public). Lowercase = unexported (private to the package). One package per directory. One directory per package. What is a module? If a package is a folder, a module is the whole project, a tree of packages with a name, a Go version requirement, and a list of external dependencies. When you start a Go project, you create a module, and inside that module, there will be packages. Every Go project has exactly one go.mod file at its root. That file defines the module. Here's what a real one looks like: module github . com / yourname / weather - cli go 1.21 require ( github . com / aws / aws - sdk - go - v2 v1 .24.0 github . com / aws / aws

I built a free 2026 World Cup prediction tool as a fun side project. The soccer part was fun, but the AI part ended up being more interesting. I tested four different prediction views: My own methodology A tournament-read model based on current form, roster age and fitness, squad depth, style matchups, counterattack danger, fatigue, climate, penalties, manager decisions, and bracket path. Betting odds only A market-based view. ChatGPT independent forecast I did not give it my methodology or preferred winner. I simply asked it to build the best prediction it could using its own logic. Gemini logic forecast This one was the most interesting. Gemini asked me who I was rooting for before making its prediction. Then, in my testing, it chose that team to win. When I changed the team I said I was rooting for, Gemini changed the winner to that team too. That stood out to me. Not because it is evil or anything dramatic like that. But it is a good reminder that AI can lean toward making the user happy. If you feed it a bias, it may hand that bias back to you with better wording and more confidence. The biggest lesson from the project was simple: Good input in, good output out. Garbage in, garbage out. AI is powerful, but it still needs human judgment. It can organize thinking, compare logic, test assumptions, and help build something useful. But it still depends on the person using it to understand the situation, challenge weak assumptions, and know when an answer sounds right but may not actually be right. The tool is a standalone HTML file. It is not a live data feed. It does not automatically update injuries, suspensions, weather, lineups, or odds movement. Users can enter live group-stage scores manually, but anything else has to be adjusted by the user. I’m curious how others think about this: When an AI asks for your preference before giving a forecast, is that helpful context, or does it risk steering the answer toward pleasing the user? Also happy to drop a link for d

Among WordPress maintenance tools, InfiniteWP is one of the most established names. Released by Revmakx in 2011, the tool has been operated continuously for over a decade. It enjoys deep loyalty from agencies that have invested years building operational know-how around it . We at WP Maintenance Manager take a different approach, and our comparison pages outline where the two diverge. But before talking about differences, the strengths of InfiniteWP deserve to be stated honestly . Here are the five points where InfiniteWP fits an agency particularly well. 1. Over a decade of operational track record InfiniteWP's biggest structural advantage is trust built across more than a decade of continuous operation . Released in 2011 — one of the oldest tools in the space A large base of long-time English-speaking users with shared operational patterns Well-defined upgrade paths from older versions Backward compatibility with existing workflows and scripts has been maintained for years For agencies already invested in InfiniteWP, switching tools means more than "migration work" — it means rebuilding the operational know-how accumulated over years . Continuing to use a tool with proven track record is, in itself, a strength that long-running platforms have. The temporal depth that newer tools simply cannot replicate is a meaningful selection reason for conservative industries — those reluctant to substantially change established workflows. 2. Self-hosted — full control of the dashboard InfiniteWP is self-hosted by default , letting you place the dashboard on your own server (a cloud-hosted version is available separately). Host on infrastructure you own Complete data ownership No dependency on external SaaS Arbitrary customization possible When the constraint is "client data must not sit in a third-party SaaS" or "our security policy doesn't permit SaaS," InfiniteWP's self-hosted architecture is a direct answer. If your team has experience operating PHP / WordPress infrastructu

The End of Vibe Coding: Why I Switched to Structured AI Workflows I spent 3 months "vibe coding" my SaaS. Then I realized I was spending more time fixing AI's mistakes than if I'd written it myself. Here's the system that changed everything. In early June 2026, two HN threads with a combined ~1,300 comments told me something had shifted. Thread 1 (~1,100 comments): "What was your 'oh shit' moment with GenAI?" Thread 2 (~230 comments): "What tools have you made for yourself since AI?" Both threads had the same pattern: people started with unfiltered excitement ("I built a whole app in one weekend!"), then hit a wall ("I'm spending more time fixing its bugs than writing code from scratch"). I know the feeling. I lived it. The Vibe Coding Trap When I started building MultiPost — an AI-powered cross-platform content tool — I was deep in "vibe coding" mode: Me: "Make it look better" AI: *adds Tailwind, restyles everything* Me: "Add a filter by date" AI: *adds a date picker, breaks the layout* Me: "Fix that bug where posts don't show" AI: *fixes the filter, introduces a null pointer* Me: "Okay now add a dark mode toggle" AI: *regenerates half the component from scratch* Three weeks later I had a working feature and zero understanding of how any of it actually held together. This was my daily rhythm for weeks. Fast output, slow cleanup. The ratio kept getting worse as the codebase grew. I was optimizing for speed of generation instead of speed of delivery . The "Oh Shit" Moment It came when I reviewed a feature I'd built entirely through unstructured AI sessions. The feature worked. But: The code had 3 different patterns for the same thing (Auth0 token handling in one place, hardcoded keys in another) Error handling was inconsistent — some functions returned null, others threw, others returned Result types Database queries were scattered across the codebase instead of in a repository layer A security reviewer would have cried The AI didn't do this maliciously. It did this

Your health data is probably the most sensitive information you own. Yet, most "AI Health Assistants" today require you to ship your symptoms, moods, and medical history to a cloud server. In the era of Edge AI and Privacy-preserving machine learning , this is no longer a trade-off we have to make. By leveraging the MLX Framework and Apple Silicon's unified memory, we can now run on-device LLMs like Llama-3-8B directly on an iPhone. This tutorial explores how to build a 100% offline, local health journal that summarizes your daily wellness without a single byte leaving your device. If you're looking for more production-ready patterns for secure AI, definitely check out the advanced guides over at Wellally Tech Blog . Why MLX-Swift? 🍏 Apple's MLX is a NumPy-like array framework designed specifically for Apple Silicon. When brought into the Swift ecosystem via mlx-swift , it allows us to tap into the GPU and Neural Engine with incredible efficiency. The Architecture: 100% Offline Inference Unlike traditional CoreML conversions that can be rigid, MLX allows for dynamic graph execution. Here is how the data flows from your typed notes to a structured health summary: graph TD A[User Input: Health Notes] --> B[SwiftUI View] B --> C{Privacy Layer} C -->|Local Only| D[MLX-Swift Engine] D --> E[Llama-3-8B Quantized Model] E --> F[Unified Memory / GPU] F --> G[Local Inference] G --> H[Markdown Health Summary] H --> B style C fill:#f9f,stroke:#333,stroke-width:4px style E fill:#00ff0022,stroke:#333 Prerequisites 🛠️ Device : iPhone 15 Pro or later (8GB RAM is highly recommended for Llama-3-8B). Software : Xcode 15.3+, iOS 17.4+. Tech Stack : MLX Framework, SwiftUI, Llama-3-8B (4-bit quantized). Step 1: Setting Up the MLX Engine First, we need to integrate the mlx-swift package. In your Package.swift , add: . package ( url : "https://github.com/ml-explore/mlx-swift-chat" , branch : "main" ) Now, let's initialize the model. Because we are on a mobile device, we must use a quantiz

Webflow's code export has two problems. It is only available on paid Workspace plans, and even when you pay, it does not include your CMS content: collection lists export as empty states, collection pages export with nothing in them. If your site has a blog, the export gives you a site without a blog. Forms and search are disabled in exported code too, per Webflow's own docs. Meanwhile, the published site is sitting on a CDN, fully rendered. Every CMS page is real HTML. wget --mirror will happily fetch all of it. What wget gives you, though, is not deployable. I migrated a production Webflow site this way and hit the same five breakages everyone hits, so I turned the fixes into a Claude Code skill that runs the whole workflow. This post is the five breakages, because they are useful whether or not you use the skill, and they apply to Framer, Squarespace, and friends with different domain names. Setup: the mirror itself The one wget incantation that matters, because Webflow serves assets from a separate CDN domain and you have to tell wget to follow it: wget --mirror --convert-links --adjust-extension \ --page-requisites --span-hosts \ --domains = yourdomain.com,cdn.prod.website-files.com \ --no-parent https://yourdomain.com/ This downloads every page plus the CSS, JS, images, and fonts they reference, and rewrites URLs to relative paths. It looks complete. It is about 90% complete, and the missing 10% is invisible until the page renders blank. Breakage 1: the page renders blank, console says "integrity" The symptom: your mirrored page shows raw unstyled text or nothing at all, and the console says Failed to find a valid digest in the 'integrity' attribute . The cause is subtle. Webflow ships its <link> and <script> tags with SHA-384 SRI hashes. wget's --convert-links rewrites URLs inside the downloaded CSS files, which changes their bytes, which means the SRI hash no longer matches, which means the browser silently refuses to apply the stylesheet. The file is right

Most AI agent systems start with a simple idea: "Let's give the Agent Memory". At first, this usually means saving previous messages, retrieving similar chunks, and injecting them back into the prompt. That works for demos. It does not work reliably for real organizational workflows. Because chat history is not memory. A vector database is not memory. A bigger context window is not memory. Those are storage and retrieval mechanisms. Useful, yes. But memory in an AI Agent System is not just about remembering more information. It is about deciding what should influence future behavior. And that is a much harder problem. The Simple Version When people say "Agent Memory", they often mix together very different things: Conversation history User preferences Workflow state Previous tool results Retrieved documents Task summaries Business rules Approved policies Model-generated assumptions Evidence of completed actions But these should not all be treated the same way. A user saying "I usually prefer short answers" is not the same kind of memory as "invoice #123 was paid". A model saying "the client is probably interested" is not the same as a CRM record. A previous chat message is not the same as a runtime audit log. An approved company policy is not the same as a generated summary. When all of these are thrown into the same context window, the agent may look smarter for a while. Then it slowly becomes unreliable. More Context Can Make Agents Worse A common instinct is to give the agent more context. More history. More documents. More summaries. More retrieved chunks. More memory. But more context does not automatically mean better reasoning. Sometimes it means more noise. Sometimes it means stale information. Sometimes it means private information leaking into the wrong task. Sometimes it means the model starts treating old assumptions as current facts. Sometimes it means low-authority memory overrides high-authority evidence. This is one of the strange things about AI Age

There is a design assumption baked into almost every vector database and AI memory implementation that sounds reasonable until you watch it grow nodes in production: that remembering more is always better. Through testing and refining our AUDN code, that is not exactly correct. After running VEKTOR Slipstream against real development sessions for 99 days, the database held 1,413 stored memories across four namespaces. Looking at the importance score distribution, 83 percent of those memories sat below 0.25 out of 1.0, what the system considers the noise floor. The remaining 17 percent, just 60 memories out of 1,413, sat above 0.75 and dominated every recall result. This is exactly what a curation layer is supposed to produce. Those 1,154 low-scored memories are accurate. They are not deleted. They are retrievable by direct query. What they are not is important enough to compete with the 60 high-signal entries every time the agent needs context. AUDN penalised them gradually over hundreds of writes because similar, more specific, or more frequently reinforced memories covered the same ground better. The system created a hierarchy. Without curation, all 1,413 memories would compete equally for every recall slot — and the agent would consistently surface redundant, lower-value context alongside the things that actually matter. That is what standard vector memory looks like without a curation layer. A slow, invisible degradation that nobody notices until the agent starts confidently giving you answers that are three months out of date. Every memory node in Vektor carries an importance score between 0 & 1. When a memory is first stored, it receives a score based on the content’s estimated significance. That score is not fixed. Every time a new memory arrives that is semantically related but not directly contradictory, the compatible verdict for that existing memory takes a small redundancy penalty. The penalty is intentionally modest: a factor based on how similar the in

I generated videos with Omni and want to remove the visible and possibly invisible watermarks it applies. I have only seen tools for pictures but none for videos so far. submitted by /u/Born-Explanation-544 [link] [留言]

I recently tackled the "AI memory" rabbit hole on other subreddits and this sub and I found out that people have different way of tackling this problem. Most notably being: - Notes - Git trees So my question is: How do you manage AI memory and how would you make it better? submitted by /u/Haunting-Bother7723 [link] [留言]

Imagine you lose your work laptop on a commute. It holds 3 years of customer PII, internal product roadmaps, and access keys to your company's cloud infrastructure. Without full disk encryption enabled, anyone who finds the device can access every file in 10 minutes or less with a free bootable USB tool. With encryption enabled? They'll never access your data, even if they brute-force the password for decades. Per IBM's 2025 Cost of a Data Breach Report, organizations that use encryption save significantly on breach costs compared to teams that skip encryption. As cyber threats grow more sophisticated, and quantum computing edges closer to breaking legacy cryptographic standards, encryption is no longer an optional add-on—it's a core requirement for every digital system. This guide breaks down everything you need to know about data encryption, from core concepts to 2026's latest post-quantum developments, with actionable best practices for teams of all sizes. Table of Contents Core Concepts of Data Encryption How Does Data Encryption Work? Key Data Encryption Algorithms (2026 Approved & Deprecated) Encryption for All 3 Data States: At Rest, In Transit, In Use Real-World Data Encryption Use Cases Encryption Standards & Compliance Regulations Data Encryption Best Practices Common Encryption Mistakes to Avoid 2024-2026 Encryption Trends & Future Developments Conclusion & Key Takeaways References Core Concepts of Data Encryption Data encryption is a cryptographic process that converts human-readable plaintext into unreadable scrambled ciphertext using mathematical algorithms and secret keys. Only authorized parties with the correct decryption key can reverse the process to recover the original plaintext. Core Benefits of Encryption Encryption provides three non-negotiable security properties: Confidentiality : Only authorized users can access sensitive data Authentication : Verifies the origin of encrypted data Integrity : Confirms encrypted data has not been tampered w

By the end of this article you'll have a small Node.js script that pipes a module-resolution error ( ERR_REQUIRE_ESM , ERR_MODULE_NOT_FOUND , Cannot use import statement outside a module ) plus the surrounding config into Claude and gets back a specific fix — not a Stack Overflow lecture. You'll also have four hardened prompts you can paste straight into claude.ai, and a script that auto-detects whether your project is CJS or ESM before you even ask. Everything below runs on Node 18+. Why "just use ESM" doesn't fix the CommonJS/ESM ERR_REQUIRE_ESM error The reason these errors waste so much time is that the failing line is almost never where the problem lives. You see this: Error [ERR_REQUIRE_ESM]: require() of ES Module /app/node_modules/node-fetch/src/index.js from /app/server.js not supported. and your instinct is to edit server.js . But the actual decision is made by four things you can't see from the traceback: the "type" field in your package.json , the "type" (or "exports" map) in the dependency's package.json , your file extension ( .js vs .mjs vs .cjs ), and — if you use TypeScript — the module and moduleResolution fields in tsconfig.json . node-fetch v3 went ESM-only; that's why require('node-fetch') blows up while v2 was fine. The traceback tells you none of that. This is exactly the shape of problem an LLM is good at: lots of small context scattered across files, one correct answer, and a human who keeps pattern-matching on the wrong line. The trick is to feed Claude the config alongside the error, not the error alone. A prompt that only gets the stack trace will confidently tell you to "convert your project to ESM," which is often the most destructive possible fix. Prompt 1 for Claude: force a root-cause classification before any code The failure mode of asking an AI to "fix my module error" is that it jumps to a rewrite. The fix is to make it classify first. Paste this into claude.ai, filling the three blocks: You are debugging a Node.js module resolut

I Had 6 Side Projects Open in One Browser Window. Here's What That Was Costing Me. I counted once, on a normal Tuesday. 41 tabs, one window, six different side projects. A repo here, a localhost there, a Stripe dashboard, two Notion pages, a half-read Stack Overflow thread I was scared to close. I was using a tab manager to hold it all together. Save the session, restore it later, feel organized. It worked, in the sense that nothing got lost. But something was off, and it took me a while to name it. The tab manager was keeping my tabs. It was not keeping my projects. And the gap between those two things was quietly costing me. The number that bothered me I did a rough audit of one week. Every time I sat down to work on a project, I had to reconstruct where I was. Which task was next? When was that thing due? Where did I save that reference last month? The tabs were there, but the answers were not in the tabs. I timed it loosely. Five to ten minutes of "wait, where was I" at the start of every session, multiplied across six projects, multiplied across a week. Call it an hour, maybe more, spent just getting back to the surface before any real work started. An hour a week is not a catastrophe. But it was an hour spent doing something a tool should do for me, and the friction was enough that I started avoiding the projects with the most tabs. The cost was not really the time. It was that the heaviest projects felt the worst to open, so I opened them least. Why the tab manager could not fix this Here is the thing I had to admit. A tab manager is excellent at one job: saving and restoring tabs. It is not built to know anything about the project those tabs belong to. A tab is a URL. A project is a URL plus: A task that is due Friday A reference I saved three weeks ago and need again now A subscription renewing on the 14th A sense of what I actually shipped last time I worked on it When all of that lives outside the tab manager, in a to-do app, a notes file, my memory, rest

OpenAI plans to acquire Ona to expand Codex with secure, persistent cloud environments, enabling long-running AI agents across enterprise workflows.