标签：#web

After several weeks of optimization and community feedback, AnimaStage Lite v1.2.3 is now available. The biggest milestone of this release is that AnimaStage Lite is now available on Google Play, alongside the browser version. 📱 Google Play https://play.google.com/store/apps/details?id=com.webmmd.suite 🌐 Browser https://animastage-lite.app What's new in v1.2.3 📱 Google Play Release AnimaStage Lite is now officially available on Android through Google Play, making it easier to access the editor without manually installing APKs. ⚡ Multi-model performance improvements Working with multiple characters is now much smoother. Improvements include: Performance governor now reacts to the number of visible models. Background characters use a lighter rendering path. When playback is paused, Bullet Physics is simulated only for the selected character. Bullet Physics substeps are capped to improve stability and maintain FPS. 🔄 Physics stability A new Global Physics Stability Registry helps keep simulations more reliable across different scenes. Added: Fix Physics — a soft physics reset that restores the simulation without interrupting the animation timeline. This was implemented after feedback from users who experienced unstable physics when working with multiple models. 🛠 Bug fixes Fixed: SITE_URL is not defined in officialProject.ts General stability improvements Various internal cleanups Project goals AnimaStage Lite is an experimental browser-native MikuMikuDance studio built with WebGL and WASM. Current features include: PMX / PMD support VMD animation playback Bullet Physics Timeline editor MP4 export Browser + Android support The long-term goal is to make MMD creation accessible without requiring a desktop installation. Links 🌐 Website https://animastage-lite.app 📱 Google Play https://play.google.com/store/apps/details?id=com.webmmd.suite 💻 GitHub https://github.com/FBNonaMe/animastage-lite Feedback, bug reports, and feature suggestions are always appreciated. Every relea

A customer texted me a screenshot last month. It was my own landing page, open on their Pixel. The headline — "Financial infrastructure to grow your revenue" — was clipped at "...grow your reven". The signup button below it was gray-on-slightly-lighter-gray, basically unreadable. And the hero image? A broken-image icon. Here's the part that stung: every check I had was green. Lighthouse: 98. My Playwright tests: passing. CI: all checkmarks. I had shipped that page an hour earlier feeling good about it. None of my tooling caught any of it. I want to walk through why , because I think a lot of us have this blind spot, and then I'll tell you what I did about it. CI tests the DOM. It does not test what a human sees. This is the core issue. My tests asserted things like "the signup button exists" and "the form has an email input." All true. The button was in the DOM . It just rendered unreadable on a 412px-wide screen with the system in light mode. Lighthouse runs one viewport (usually a throttled Moto G4 emulation) and scores performance/SEO/a11y heuristically . It does not look at your page across the actual range of devices your visitors use and say "this headline is physically clipped on a Pixel 8." And my "responsive testing"? I was dragging the Chrome devtools responsive bar to two breakpoints — 375 and 1440 — eyeballing it, and moving on. That's not testing. That's hoping. The three bugs that slipped through Let me get specific, because the category of each bug is instructive. 1. The clipped headline — a measurable, deterministic bug .hero-title { white-space : nowrap ; /* the culprit */ width : 100% ; overflow : hidden ; } On desktop, the headline fit. On a narrow viewport, white-space: nowrap refused to wrap, overflow: hidden clipped the overflow, and the last word vanished. The brutal thing: this is trivially detectable in code . The element's scrollWidth was greater than its clientWidth . That's a one-line check: const clipped = el . scrollWidth > el . clientW

TRON Vanity Address Generator: How to Get a Custom Wallet Address That Stands Out If you've spent any time in crypto, you've probably noticed that most wallet addresses look like random noise — a string of 34 characters nobody remembers and nobody trusts at a glance. That's exactly the problem vanity addresses solve, and it's exactly what the new tool at tronsec.io/app is built for: generating custom TRON (TRX/USDT-TRC20) addresses that start or end with a sequence you choose. What Is a Vanity Address, Exactly? A vanity address is a regular blockchain wallet address that contains a custom, human-readable pattern — your name, your project's ticker, a lucky number, anything you like — instead of (or alongside) a random string of characters. Technically, nothing about a vanity address is different from any other address. It's generated by the same elliptic curve cryptography as every other TRON wallet. The "vanity" part comes from brute-forcing key pairs until one produces a public address matching your desired pattern. The private key is yours, generated locally, and the math behind it is identical to a standard wallet — there's no special vulnerability baked in just because the address looks nicer. Why Traders and Crypto Projects Actually Use Them It's easy to dismiss vanity addresses as a cosmetic gimmick, but there are real, practical reasons they've become popular in the TRON ecosystem specifically — especially since TRON is the dominant network for USDT transfers. 1. Phishing and typosquat protection. TRON addresses are long Base58 strings. Most users only glance at the first and last few characters before confirming a transfer. Scammers exploit this by generating addresses that look similar to a target address (this is sometimes called address poisoning) and slipping them into transaction history hoping you copy the wrong one. A vanity address with a recognizable prefix — say, your project name or a distinctive token — makes it much harder for a lookalike addres

Let's be honest—traditional A/B testing is broken. If you've ever implemented client-side testing, you know the drill. Your users load the page, wait for JavaScript to execute, and then—flicker—the content changes. It's jarring. It hurts your Core Web Vitals. And worst of all, your experiments might be measuring user frustration instead of genuine engagement. But what if you could run A/B tests with zero flicker? What if you could modify your HTML before it even reaches the browser? That's exactly what Cloudflare Workers make possible . The Server-Side Advantage A/B testing at the edge means making decisions about which variant a user sees before any HTML is sent to their browser . Instead of: Load the page Execute JavaScript Flicker Apply the variant Track the result You get: Decision made at the edge Correct HTML streamed immediately Zero flicker Better performance Companies like Ninetailed are already using Cloudflare Workers to achieve 2-3x cost savings compared to traditional serverless platforms, all while delivering personalized experiences with minimal latency . How It Actually Works The concept is surprisingly elegant. Your Cloudflare Worker intercepts incoming requests, checks for a cookie to maintain user consistency, and routes users to the appropriate variant . Here's a simplified version that's production-ready: javascript const NAME = "myExampleWorkersABTest"; export default { async fetch(req) { const url = new URL(req.url); // Determine which group this user is in const cookie = req.headers.get("cookie"); if (cookie && cookie.includes(`${NAME}=control`)) { url.pathname = "/control" + url.pathname; } else if (cookie && cookie.includes(`${NAME}=test`)) { url.pathname = "/test" + url.pathname; } else { // New user—randomly assign them (50/50 split) const group = Math.random() < 0.5 ? "test" : "control"; url.pathname = `/${group}` + url.pathname; // Fetch and modify the response to set a cookie let res = await fetch(url); res = new Response(res.body, res

Recentemente percebi uma coisa meio curiosa: eu simplesmente tinha um problema ao consumir o conteúdo do 4noobs do jeito que ele é organizado hoje. Não porque a organização seja ruim — muito pelo contrário. Acho que a comunidade fez um trabalho incrível organizando o projeto. O ponto é que eu percebi que meu jeito de estudar é diferente: tenho muito mais facilidade quando consigo seguir listas, trilhas ou um caminho de aprendizado mais visual. Foi aí que pensei: "Se esse problema existe para mim, talvez exista para mais alguém. E se, de quebra, eu aproveitar isso para praticar consumo de APIs?" Foi assim que nasceu a Central 4noobs . A proposta era simples: consumir todo o conteúdo disponível no GitHub do 4noobs e apresentá-lo de uma forma que fizesse mais sentido para o meu jeito de estudar, organizando os materiais em listas e trilhas de aprendizado. A ideia nunca foi substituir a organização do projeto original, mas oferecer uma forma diferente de navegar pelo mesmo conteúdo. Essa era a ideia inicial... mas, como acontece com praticamente todo projeto pessoal, ela foi crescendo conforme o desenvolvimento avançava. Mas ainda é uma alternativa . Tenham em mente isso. :) O que aprendi durante o projeto O projeto foi desenvolvido utilizando Next.js , TypeScript , Drizzle ORM e Supabase como banco de dados (e hoje já não tenho tanta certeza se essa foi a escolha mais inteligente 😅). O maior aprendizado foi entender melhor como funciona o consumo de APIs. Antes eu entendia o conceito na teoria (com o próprio 4noobs , inclusive), mas foi durante o desenvolvimento da Central que realmente comecei a compreender como tudo se conecta. Depois desse projeto, passei a enxergar melhor como uma API é estruturada e, principalmente, como consumir seus dados sem simplesmente despejar tudo na tela. Outra parte interessante foi aprender a tratar os dados recebidos. Uma coisa é receber uma resposta gigantesca da API. Outra completamente diferente é filtrar apenas as informações que re

Engineers on the new team will embed within companies to deploy purpose-built agents, focusing on fast deployments and customer self-sufficiency.

Hi, I’m David. I’m close enough to middle age that I have no interest in pretending I discovered the future of software development in a week. What I did do was spend one serious week building a small local app with AI assistance, while trying to keep the project understandable. That turned out to be harder, and more interesting, than I expected. The coding agent could move quickly. Sometimes very quickly. It could generate code, refactor, write boilerplate, and help move the project forward. But it could also widen scope, preserve the wrong assumption, “helpfully” redesign something I wanted to keep boring, or act on context that was never meant to become implementation work. The main lesson I took from that week was simple: AI-assisted development is not only a coding problem. It is a context management problem. So I started using a lightweight loop: Task Brief -> think through the problem Codex Contract -> give the coding agent a bounded instruction set Final Review -> test, inspect, patch, and update project memory The result was not perfect AI coding. The result was reviewable AI coding. That distinction felt important enough to write down. The three articles I published three companion articles from that first week. They are meant to stand on their own, but together they describe the workflow, the memory system, and the objections I think are worth taking seriously. 1. Vibe Coding Done Right This is the accessible starting point. It explains how I used a lightweight, spec-driven workflow as a solo developer working with ChatGPT, Codex, VS Code, PowerShell, and a local LLM through LM Studio. The point is not the exact stack. The point is the separation: one place for thinking, learning, and review; another place for bounded implementation; documentation as the memory that keeps the next task grounded. 2. Documentation as Project Memory in AI-Assisted Development This is the more technical case-study piece. The part that surprised me most was documentation. Not

When I first started programming, I thought the best developers had one superpower. They remembered everything. Every function. Every method. Every API. Every piece of syntax. So I spent hours trying to memorize things. JavaScript methods. SQL queries. Regex. CSS properties. I thought that would make me valuable. I was wrong. The Day Everything Changed One day I watched a senior developer solve a difficult production issue. They opened Google. They opened the documentation. They searched Stack Overflow. They experimented. They tested. They failed. Then they fixed it. That's when I realized something. They weren't valuable because they remembered everything. They were valuable because they knew how to solve problems. Google Doesn't Make You Less of a Developer For a long time I felt guilty every time I searched for something. "Real developers shouldn't need Google." That's what I believed. Then I realized... Even experienced engineers search for documentation every day. Not because they're bad. Because technology changes constantly. Nobody remembers every detail. Syntax Is Temporary Think about the last five years. How many frameworks have changed? How many libraries disappeared? How many APIs were deprecated? Technology moves fast. Problem-solving doesn't. If you know how to think... You can learn any syntax. Companies Don't Hire Human Compilers Nobody pays you because you know where to put a semicolon. Nobody promotes you because you memorized every React hook. Companies pay developers who can: understand problems communicate clearly debug effectively make good decisions work with people deliver reliable software Those skills don't disappear when a framework becomes outdated. The Questions That Matter Instead of asking: "Do I know this syntax?" I started asking: Can I understand the problem? Can I break it into smaller pieces? Can I explain my thinking? Can I find reliable information quickly? Can I learn something new when I need it? Those questions changed the wa

There's a paradox nobody wants to say out loud: the same frameworks companies pick because they're "enterprise-ready," "scalable," and "industry standard" are, for an LLM writing code, a minefield. Angular , React with its whole ecosystem, Nx with its monorepos: these are powerful tools, built by humans to coordinate teams of humans on massive codebases. And for that purpose, they're often the right choice — if your primary constraint is coordinating hundreds of engineers over a decade, the conventions and tooling of an established framework earn their keep. But there's a second actor in the room now. When the one writing the code is an AI, the very traits that make these frameworks "robust" turn into pure friction. The argument I'm making isn't "Angular and React are obsolete." It's narrower: we've historically optimized software architecture for human cognition, and LLMs introduce a different cost model that may favor simpler, more deterministic architectures — at least in some domains. Let's break down why, in three points. 1. The Token Tax (and the Cognitive Bottleneck) An LLM doesn't "understand" code the way we do — it processes it token by token, and every token costs something: money, latency, and context window that could otherwise be spent reasoning about the actual problem. Try asking an AI to generate a simple input form in a typical Angular/Nx context. To do it "properly" it has to: create the component (separate .ts , .html , .css files) declare the @Component with all its metadata import and wire up the right modules possibly touch an NgModule or a standalone-components config navigate 4-5 folder levels inside a typical Nx structure ( apps/ , libs/ , feature-x/ , data-access/ , ui/ ...) All of this before writing a single line of actual logic. That's architectural complexity that, for a human, pays for itself over time thanks to tooling, autocomplete, and internalized conventions. For an LLM generating text sequentially, it's a tax paid on every singl

I had a lot of work to get through, and for once I didn't want to crawl through it one ticket at a...

Introduction I keep hearing the term loop engineering. It's all over my feed, every AI...

Stop Writing the Same Laravel Boilerplate: Generate a Complete Module with One Artisan Command Every Laravel developer has experienced this. You start implementing a new feature and immediately create the same files you've created dozens of times before: Model Migration Repository Service Form Request API Resource Policy Filter Status Enum Feature Tests Unit Tests Swagger/OpenAPI annotations The process is repetitive, time-consuming, and easy to get wrong. The Problem While Laravel provides excellent generators, building a production-ready API module still requires running many Artisan commands and wiring everything together manually. For large projects following Repository and Service Layer architectures, this becomes even more repetitive. The Solution I built Laravel Base , an open-source package that generates an entire production-ready module from a single command. php artisan make:module Product The generated module includes: ✅ Model ✅ Migration ✅ Repository Pattern ✅ Service Layer ✅ Form Requests ✅ API Resources ✅ Filters & Pagination ✅ Policies ✅ Status Enums ✅ Swagger/OpenAPI annotations ✅ Feature Tests ✅ Unit Tests Modern Development Experience The package is actively maintained and includes: Laravel 10–13 support PHP 8.1–8.4 compatibility GitHub Actions CI PHPStan static analysis Laravel Pint code style Automated releases Repository automation Why I Built It After working on multiple Laravel projects, I noticed I was spending too much time generating the same project structure instead of focusing on business logic. I wanted a tool that lets developers start implementing features immediately rather than setting up folders and classes. Feedback Welcome Laravel Base is open source, and I'd love to hear your thoughts. GitHub Repository: https://github.com/MuhammedMSalama/LaravelBase Packagist: https://packagist.org/packages/muhammedsalama/laravel-base The package was recently featured by Laravel News, and I'm continuing to improve it based on community feedbac

For twenty years, "ranking" meant one thing: get indexed, get crawled, get a position on a results page. Every Shopify store's SEO checklist was built around that single goal. Sitemap submitted, meta tags filled in, Core Web Vitals green, done. That checklist still matters. It's also no longer sufficient, and most stores haven't noticed yet. Two different systems, two different jobs Google's index and an LLM's answer engine are not the same kind of system, even though they both "read" your store. A search index is a retrieval system. It crawls a page, tokenizes the content, stores it, and matches it against a query at request time. Ranking is a function of relevance signals backlinks, click-through behavior, freshness, page experience. The unit of output is a list of links. The user does the synthesis. An LLM-based answer engine is a generation system. When someone asks ChatGPT, Perplexity, or Claude "what's a good Shopify store for sustainable activewear," the model isn't returning a ranked list of crawled pages. It's generating a single answer, and it decides which brands to name in that answer based on which entities it has high confidence are real, relevant, and well-attested across multiple sources. The unit of output is a sentence. The model does the synthesis, and your store either gets a mention in that sentence or it doesn't. This is the gap. A store can be fully indexed sitemap clean, every product page crawlable, ranking on page one for its category and still never get named in an AI-generated answer. Indexing is a necessary condition for citation. It is not a sufficient one. What "citable" actually requires Citation in an LLM context isn't about keyword matching. It's closer to reputation modeling. Three things tend to separate stores that get cited from stores that don't: Entity consistency across the web. The model needs to resolve "your brand" as a single, stable entity across multiple independent sources your own site, marketplaces, press mentions, r

React useIntersectionObserver Hook: Lazy Load & Detect Visibility (2026) You want to load an image only when it scrolls near the viewport. Or fire an analytics event the first time a card is actually seen . Or trigger "load more" when the user reaches the bottom of a list. Every one of these is the same question — is this element on screen yet? — and for years the answer was a scroll listener that fired hundreds of times a second, re-read getBoundingClientRect() on each tick, and still managed to miss the edge cases. IntersectionObserver is the browser API that answers that question correctly, asynchronously, and off the main thread. useIntersectionObserver is the hook that wires it into React without the useEffect / useRef /cleanup boilerplate — and without the leak-on-unmount and stale-closure bugs the hand-rolled version always ships. This post covers the real @reactuses/core API, the three patterns you'll actually reach for, and how to tune threshold , rootMargin , and root . SSR-safe and typed. Why Not Just Use a Scroll Listener? The old way to know whether an element was visible looked like this: listen to scroll , and on every event measure the element against the viewport. useEffect (() => { function onScroll () { const rect = el . getBoundingClientRect (); if ( rect . top < window . innerHeight ) { setVisible ( true ); } } window . addEventListener ( ' scroll ' , onScroll ); return () => window . removeEventListener ( ' scroll ' , onScroll ); }, []); This has two problems baked in. First, scroll fires on the main thread, dozens of times per second, and getBoundingClientRect() forces a synchronous layout each time — that's exactly the recipe for janky scrolling. Second, it only catches elements crossing the viewport ; the moment your scroll happens inside a container, you're re-deriving geometry by hand. IntersectionObserver flips the model. You hand the browser a target and a threshold, and it tells you — asynchronously, batched, off the scroll path — when

A few months ago I was applying for jobs and stumbled across Jobscan. It looked exactly what I needed — paste your resume, paste the job description, see how well you match. Then I saw the price. $49.95/month. As a student, that's a week of groceries. I closed the tab. But the problem didn't go away. I kept wondering — why is my resume getting rejected before a human even reads it? ATS systems are filtering people out and nobody tells you why. So I built ClearScan. What it does: Scans your resume against a job description. Shows exactly which keywords you're missing. Checks ATS compatibility across 5 platforms (Workday, Taleo, Greenhouse, Lever, iCIMS). Scores your bullet points using STAR format analysis. Gives you a transparent breakdown — you can see why you got the score you did. That last part matters to me a lot. Most tools just give you a number. ClearScan shows you the math. Where it stands: Launched today. First paying customers already. Free tier gives you 2 scans/month — enough to feel the product before deciding. Pricing starts at €3.99/month. Built for students, priced for students. Live at clearscan.fyi — would genuinely love your feedback, especially from developers who've dealt with ATS hell themselves.

OpenAI usage page, check spend. Anthropic console, check spend. Add it up in my head. Close both...

An AI gateway is the control point between your applications and the LLMs they call. It’s where cost, security, reliability, and governance get managed across every model and provider at once. Skip it, and AI sprawl quietly turns into runaway spend, security gaps, and outages you didn’t see coming. Here’s why a gateway has become core infrastructure. Almost nobody adopts AI in a tidy, planned way. One team ships a support chatbot on OpenAI. Another prototypes on Anthropic. A third fine-tunes an open model on its own GPUs because the latency was better. A year later you’ve got dozens of applications, several providers, API keys scattered across repos, and no single answer to a simple question: what are we spending, and what data are we sending where? That’s the gap an AI gateway fills. It sits between your applications and the models, and it turns fragmented, ungoverned access into something you can actually manage. The reason organizations end up needing one is straightforward — production AI creates problems that application code was never designed to solve. Let’s walk through them. The problems an AI gateway solves Cost that’s invisible until the invoice arrives LLM spend is uniquely easy to blow up. A retry bug, an agent stuck in a loop, an unbounded batch job — any of these can multiply tokens overnight. And when every team holds its own provider key, finance gets one large number with no story behind it. A gateway changes that. It enforces budgets and rate limits per user, team, and application, tracks token spend as it happens, and attributes every dollar to a cost center. TrueFoundry, for instance, lets platform teams set hard caps so a single bad deploy can’t drain the AI budget. The detail matters because cost control only works if it’s enforced before the spend, not discovered after it. Security and credential sprawl Without a gateway, provider keys end up hardcoded in notebooks, committed to repos, and copied onto laptops. There’s no clean way to rotate t

Traditional content pages are often designed for a linear reader. The introduction sets context, the middle develops the idea, and the conclusion ties everything together. AI retrieval does not always work that way. A system may identify smaller content units, pull the most relevant section, compare it with other sources, and use that fragment to support an answer. The full page still matters, but the retrievable blocks inside the page matter just as much. A useful Tumblr post explains the idea in simple terms: https://www.tumblr.com/digitalisedsoul/820825642809573376/ai-does-not-read-your-content-like-a-human?source=share For Dev Community readers, the pattern is familiar. Poorly structured inputs lead to weaker outputs. If content is dense, vague, or dependent on surrounding paragraphs, it becomes harder to extract and reuse. If content is modular, clear, and properly scoped, retrieval becomes easier. Marketing teams can learn a lot from this. A strong content page should behave like a set of well labelled components. Each section should answer a specific question. Headings should be descriptive, not decorative. Paragraphs should avoid vague references such as the above point or this approach when the section may be read independently. Definitions should appear close to the terms they explain. Examples should include enough context to stand alone. Proof should be written as text, not only displayed as graphics. Internal links should connect related concepts in a way that helps both readers and systems understand the topic map. A page about AI search visibility, for example, should not only include one broad explanation. It should break the topic into useful blocks: what AI visibility means, why AI systems retrieve passages, how source trust works, what makes content reusable, and how brands should measure answer presence. Each block becomes a possible answer unit. That structure does not weaken the reader experience. It improves it. Developers, marketers, and busi

I needed to convert 500 product images from one format to another. Server-based solutions quoted $15-50/month for batch processing. So I built a client-side solution using Web Workers and OffscreenCanvas. The Architecture The key insight: Canvas operations on large images block the main thread. The fix: Web Workers handle image decoding/encoding off the main thread OffscreenCanvas renders without DOM access — perfect for worker contexts Transferable objects pass image data between workers with zero-copy const worker = new Worker ( ' processor.js ' ); const canvas = new OffscreenCanvas ( 800 , 600 ); // Worker processes image, main thread stays responsive Real Performance Processing 500 images (average 2MB each) on a mid-range laptop: Server upload approach: 12 minutes (mostly upload time) Browser-local with Workers: 3 minutes 40 seconds Memory usage: Stable at ~400MB with proper cleanup The Tools I packaged this into webp2png.io for batch WebP conversion and svg2png.org for vector batch processing. For barcode generation, genbarcode.org uses similar worker-based rendering for bulk label generation. If you're processing more than 50 images, Workers + OffscreenCanvas is the way to go. Your server bill will thank you.

Most of us share files constantly: config files, API specs, design assets, build artifacts. And most of us don't think too hard about where they end up. That's exactly what Zero-Knowledge Architecture (ZKA) is designed to address. But the term gets thrown around loosely, so let's break down what it actually means — and what to look for. The Core Idea: The Server Shouldn't Have to Trust You Traditional cloud storage works roughly like this: You upload a file The server encrypts it (or doesn't) The server holds the key You trust them not to look Zero-knowledge flips this entirely. In a true ZKA system: Encryption happens on your device , before data leaves your control The keys never leave your side — the server never sees them The server handles only encrypted blobs — it's a pipe, not a vault The phrase you'll hear is: "We can't read your data even if we wanted to." That's the point. Why This Actually Matters Here's a concrete scenario: you're sharing a .env file with a contractor. You use a cloud service. The service gets breached a week later. With standard encryption (server holds the key): the attacker potentially has your secrets. With ZKA: the attacker has an encrypted blob that's useless without the key they never had. Beyond breach scenarios, ZKA also helps with: Regulatory compliance — GDPR, HIPAA, and similar frameworks become easier to demonstrate when the service provider has zero access to the data Reduced trust surface — you're not trusting the company, their employees, or anyone who might compel them legally What Real ZKA Looks Like in Practice There's a big difference between claiming zero-knowledge and actually implementing it. Here's what to look for: ✅ Client-side encryption Files should be encrypted in the browser or app before upload. Not on the server. If encryption happens server-side, it's not zero-knowledge — it's just encrypted storage. ✅ Key management stays with you Where do the keys come from? How are they shared with recipients? In a rea