Frontend Feeds

Today

Front-end, in one read.

The latest from the sources worth following, newest first.

  • Web Tools WeeklyMulti Author Blogsread at source

    Web Tools Weekly Issue #692

    JS Libs, AI Tools, Media Tools

  • DEV CommunityThe Giantsread at source

    SPA SEO in 2026: Googlebot Renders Your App. ChatGPT Doesn't.

    Most SPA SEO advice answers one question: will Googlebot see my content? Googlebot fetches the HTML, queues the page, runs your JavaScript in a headless Chromium and indexes what comes out. Slow, sometimes flaky, but it gets there. The AI crawlers don't get there. ChatGPT's crawlers fetch the HTML and stop. If your app mounts into an empty , that empty div is the whole page as far as ChatGPT search is concerned. We build LovedByAI , an AI search optimization platform for small businesses. Our WordPress plugin logs every request a recognised bot makes to a site, which is where the crawler numbers below come from. This post is the developer version of our breakdown of dynamic bot rendering , a CDN feature now being pitched to marketers as the fix. It includes a standard-library Python script that shows what each crawler gets from a URL, and that spots dynamic rendering from the outside. We ran it before publishing; the output below is real. Do AI crawlers render JavaScript? No, not the ones that matter for ChatGPT. Vercel's December 2024 study found that none of the major AI crawlers executed JavaScript, including ChatGPT-User, OAI-SearchBot, GPTBot, ClaudeBot and PerplexityBot. ChatGPT and Claude did download JavaScript files (11.50% and 23.84% of their requests), but never ran them. The exceptions were Gemini, which uses Googlebot's rendering infrastructure, and AppleBot. So for an SPA there are two audiences now: Googlebot , which renders. Your existing SPA SEO work (rendering budget, updates, history routing, hydration errors) still applies. Everything OpenAI, Anthropic and Perplexity send , which reads the HTML you return and nothing after it. Which AI crawlers should an SPA care about? AI bots come in three kinds, and they do different jobs: Kind Examples What it does Share of AI bot requests Training crawlers GPTBot, ClaudeBot, Meta-ExternalAgent Copy pages to train future models 69.9% Search index crawlers OAI-SearchBot, PerplexityBot, Claude-SearchBot Crawl ahead of time to build the index an assistant searches when someone asks 18.8% Live fetchers ChatGPT-User, Claude-User, Perplexity-User Open one page at the moment a person asks, to read it for the answer 11.3% The shares are from LovedByAI's logs: the average across 924 WordPress sites running our plugin, nearly three in four of them small and mid-sized businesses, from 6 September to 5 October 2026. An app with a different audience will have a different mix, but the reach is worth knowing: in that window OAI-SearchBot crawled 90.6% of the sites and ChatGPT-User 91.7%. The one to worry about is OAI-SearchBot. OpenAI uses it to surface websites in ChatGPT search. If it reads an empty shell, ChatGPT search has little more than your to go on for that URL. How do you see what each crawler gets from a page? Fetch the page with each crawler's user agent and count the visible words in the raw HTML, before any JavaScript. That's what bot_view.py does. For every URL it: fetches as a desktop browser, Googlebot, OAI-SearchBot, ChatGPT-User and GPTBot, using the user-agent strings Google and OpenAI publish; reports the status, the first and the visible word count, skipping , , , and ; flags an empty shell : fewer than 50 visible words, with the app root ( #root , #app , #__next , #__nuxt , #___gatsby ) empty; flags a page that differs by user agent : a different status, title, H1 or a big gap in word count compared with the browser fetch. The second check matters more than it looks. A crawler getting a different page than a browser is what dynamic rendering, a bot-blocking firewall and cloaking all look like from outside. The script can't tell you which one it is, only that you should go and look. #!/usr/bin/env python3 """ bot_view.py: what does each crawler get from your page before any JavaScript runs? Fetches every URL as a desktop browser, Googlebot, OAI-SearchBot, ChatGPT-User and GPTBot, using the user-agent strings Google and OpenAI publish, and reports the status, the first and the number of visible words in the raw HTML (titles are compared too). It flags two things: 1. EMPTY SHELL: the raw HTML has almost no visible text (an app root such as " root " > with nothing inside, filled later by JavaScript). Crawlers that don ' t run JavaScript, which today means OpenAI ' s and most other AI crawlers, read exactly this. 2. DIFFERS BY USER AGENT: a crawler gets a different title, H1, status or amount of text than the browser does. That ' s what dynamic rendering (a pre-rendered snapshot served to some bots) or a bot-blocking firewall looks like from the outside. Same content in a different shape is fine; different content is cloaking. Standard library only. Python 3.9+. Usage: python3 bot_view.py https://example.com/ [more URLs] [--min-words 50] Exit code 1 if anything was flagged, so it can run in CI. """ import argparse import re import sys import urllib.error import urllib.request from html.parser import HTMLParser # Published user-agent strings, October 2026. Google's docs write Googlebot's # Chrome version as W.X.Y.Z (it follows current Chrome); any recent version works. AGENTS = [ ( " Browser " , " Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 " " (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36 " ), ( " Googlebot " , " Mozilla/5.0 (Linux; Android 6.0.1; Nexus 5X Build/MMB29P) AppleWebKit/537.36 " " (KHTML, like Gecko) Chrome/141.0.0.0 Mobile Safari/537.36 " " (compatible; Googlebot/2.1; +http://www.google.com/bot.html) " ), ( " OAI-SearchBot " , " Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 " " (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36; compatible; " " OAI-SearchBot/1.4; +https://openai.com/searchbot " ), ( " ChatGPT-User " , " Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko); compatible; " " ChatGPT-User/1.0; +https://openai.com/bot " ), ( " GPTBot " , " Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko); compatible; " " GPTBot/1.4; +https://openai.com/gptbot " ), ] # Ids that single-page apps mount into (React, Vue, Next.js, Nuxt, Gatsby, Angular-ish). APP_ROOTS = { " root " , " app " , " __next " , " __nuxt " , " ___gatsby " , " svelte " , " main-app " } SKIP = { " script " , " style " , " noscript " , " template " , " svg " , " head " , " title " } VOID = { " area " , " base " , " br " , " col " , " embed " , " hr " , " img " , " input " , " link " , " meta " , " source " , " track " , " wbr " } class PageText ( HTMLParser ): """ Collects the title, first H1, visible text and any empty app root. """ def __init__ ( self ): super (). __init__ ( convert_charrefs = True ) self . stack = [] # open tags, to know when we're inside etc. self . title , self . h1 , self . text = [], [], [] self . in_h1 = False self . h1_done = False self . scripts = 0 self . root_id , self . root_depth , self . root_words = None , None , 0 self . empty_root = None def handle_starttag ( self , tag , attrs ): if tag == " script " : self . scripts += 1 if tag in VOID : return self . stack . append ( tag ) if tag == " h1 " and not self . h1_done : self . in_h1 = True el_id = dict ( attrs ). get ( " id " ) if el_id in APP_ROOTS and self . root_id is None : self . root_id , self . root_depth , self . root_words = el_id , len ( self . stack ), 0 def handle_endtag ( self , tag ): if tag in VOID or tag not in self . stack : return while self . stack : # tolerate unclosed tags closed = self . stack . pop () if closed == " h1 " and self . in_h1 : self . in_h1 , self . h1_done = False , True if self . root_depth is not None and len ( self . stack ) self . root_depth : if self . root_words == 0 : self . empty_root = self . root_id self . root_depth = None if closed == tag : break def handle_data ( self , data ): if " title " in self . stack : self . title . append ( data ) if any ( t in SKIP for t in self . stack ): return words = data . split () if not words : return self . text . extend ( words ) if self . in_h1 : self . h1 . append ( data ) if self . root_depth is not None : self . root_words += len ( words ) def clean ( parts , limit = 40 ): s = re . sub ( r " \s+ " , " " , " " . join ( parts )). strip () return s if len ( s ) limit else s [: limit - 1 ] + " … " def fetch ( url , ua ): req = urllib . request . Request ( url , headers = { " User-Agent " : ua , " Accept " : " text/html,*/* " }) try : with urllib . request . urlopen ( req , timeout = 20 ) as r : status , body , ctype = r . status , r . read ( 5_000_000 ), r . headers . get_content_charset () except urllib . error . HTTPError as e : status , body , ctype = e . code , e . read ( 5_000_000 ), e . headers . get_content_charset () except Exception as e : # DNS, TLS, timeout: report it as a row, keep going return { " status " : f " ERR { type ( e ). __name__ } " , " title " : "" , " h1 " : "" , " words " : 0 , " scripts " : 0 , " empty_root " : None } p = PageText () p . feed ( body . decode ( ctype or " utf-8 " , errors = " replace " )) p . close () return { " status " : status , " title " : clean ( p . title , 10_000 ), " h1 " : clean ( p . h1 , 10_000 ), " words " : len ( p . text ), " scripts " : p . scripts , " empty_root " : p . empty_root } def check ( url , min_words ): rows = [( name , fetch ( url , ua )) for name , ua in AGENTS ] print ( f " \n { url } " ) print ( f " { ' agent ' : 14 }{ ' status ' : 7 }{ ' words ' : > 6 } h1 " ) for name , r in rows : print ( f " { name : 14 }{ str ( r [ ' status ' ]) : 7 }{ r [ ' words ' ] : > 6 , } { clean ([ r [ ' h1 ' ]]) or ' (no h1) ' } " ) flags = [] shells = {} # same reason -> the agents it applies to, so five bots make one line for name , r in rows : if isinstance ( r [ " status " ], int ) and r [ " status " ] 400 and r [ " words " ] min_words : why = f " { r [ ' words ' ] } visible words " if r [ " empty_root " ]: why += f ' , empty " { r [ " empty_root " ] } " > ' if r [ " scripts " ]: why += f " , { r [ ' scripts ' ] } script tag { ' s ' * ( r [ ' scripts ' ] ! = 1 ) } " shells . setdefault ( why , []). append ( name ) for why , names in shells . items (): who = " every agent " if len ( names ) == len ( rows ) else " , " . join ( names ) note = " Googlebot renders JavaScript later; OpenAI ' s crawlers don ' t. " if " Googlebot " in names else "" flags . append ( f " EMPTY SHELL for { who } : { why } . { note } " ) base = rows [ 0 ][ 1 ] for name , r in rows [ 1 :]: diffs = [] if r [ " status " ] != base [ " status " ]: diffs . append ( f " status { base [ ' status ' ] } -> { r [ ' status ' ] } " ) if r [ " title " ] != base [ " title " ]: diffs . append ( " title " ) if r [ " h1 " ] != base [ " h1 " ]: diffs . append ( " h1 " ) gap = abs ( r [ " words " ] - base [ " words " ]) if gap > 50 and gap > 0.2 * max ( r [ " words " ], base [ " words " ]): diffs . append ( f " words { base [ ' words ' ] : , } -> { r [ ' words ' ] : , } " ) if diffs : flags . append ( f " DIFFERS BY USER AGENT for { name } vs Browser: { ' , ' . join ( diffs ) } . " ) for f in flags : print ( f " ! { f } " ) if not flags : print ( " ok: every agent gets the same page, with text in the HTML. " ) return bool ( flags ) def main (): ap = argparse . ArgumentParser ( description = __doc__ . split ( " \n " )[ 0 ]) ap . add_argument ( " urls " , nargs = " + " ) ap . add_argument ( " --min-words " , type = int , default = 50 , help = " fewer visible words than this counts as an empty shell (default 50) " ) a = ap . parse_args () flagged = [ check ( u , a . min_words ) for u in a . urls ] sys . exit ( 1 if any ( flagged ) else 0 ) if __name__ == " __main__ " : main () What does bot_view.py show on a single-page app? Here's the demo app we used, a plumber's homepage built the SPA way: index.html holds and one script tag, and app.js fills in the headline, services and reviews. Served locally with python3 -m http.server 8790 : $ python3 bot_view.py http://localhost:8790/ http://localhost:8790/ agent status words h1 Browser 200 0 (no h1) Googlebot 200 0 (no h1) OAI-SearchBot 200 0 (no h1) ChatGPT-User 200 0 (no h1) GPTBot 200 0 (no h1) ! EMPTY SHELL for every agent: 0 visible words, empty , 1 script tag. Googlebot renders JavaScript later; OpenAI's crawlers don't. Every agent gets the same empty shell: a and no text. In a browser, the page shows a headline, three service cards and a five-star review. Googlebot gets there in its rendering pass. ChatGPT-User, OAI-SearchBot and GPTBot never do. And here is a server-rendered page, our own GEO checklist (a Next.js page rendered on the server): $ python3 bot_view.py https://www.lovedby.ai/blog/geo-checklist https://www.lovedby.ai/blog/geo-checklist agent status words h1 Browser 200 4,243 GEO Checklist: 30 On-Page Checks for AI… Googlebot 200 4,243 GEO Checklist: 30 On-Page Checks for AI… OAI-SearchBot 200 4,243 GEO Checklist: 30 On-Page Checks for AI… ChatGPT-User 200 4,243 GEO Checklist: 30 On-Page Checks for AI… GPTBot 200 4,243 GEO Checklist: 30 On-Page Checks for AI… ok: every agent gets the same page, with text in the HTML. Same 4,243 words for every agent, and the H1 in the HTML. That's the result you want. What does dynamic bot rendering look like from outside? Dynamic bot rendering is the old dynamic rendering pattern pointed at AI assistants. A rule on your CDN (CloudFront, Cloudflare or Vercel) checks the user agent for a list of assistant tokens such as chatgpt-user , claude-user and perplexity-user . Matching requests get a stored, pre-rendered snapshot of the page. Everyone else, OAI-SearchBot included, gets the live page. To see what that looks like to the script, we built a toy version: the same demo app, plus a server that hands a pre-rendered snapshot.html to the nine assistant tokens on the published list. ASSISTANT_TOKENS = ( " chatgpt-user " , " codex " , " claude-user " , " claude-code " , " perplexity-user " , " gemini-deep-research " , " duckassistbot " , " amzn-user " , " mistralai-user " ) ROOT = os . path . join ( os . path . dirname ( os . path . abspath ( __file__ )), " demo " ) class Handler ( http . server . SimpleHTTPRequestHandler ): def __init__ ( self , * a , ** kw ): super (). __init__ ( * a , directory = ROOT , ** kw ) def do_GET ( self ): ua = ( self . headers . get ( " User-Agent " ) or "" ). lower () if self . path in ( " / " , " /index.html " ) and any ( t in ua for t in ASSISTANT_TOKENS ): self . path = " /snapshot.html " super (). do_GET () Run against it: $ python3 dynamic_demo.py 8793 & $ python3 bot_view.py http://localhost:8793/ http://localhost:8793/ agent status words h1 Browser 200 0 (no h1) Googlebot 200 0 (no h1) OAI-SearchBot 200 0 (no h1) ChatGPT-User 200 64 Emergency plumber in Leeds, open 24/7 GPTBot 200 0 (no h1) ! EMPTY SHELL for Browser, Googlebot, OAI-SearchBot, GPTBot: 0 visible words, empty , 1 script tag. Googlebot renders JavaScript later; OpenAI's crawlers don't. ! DIFFERS BY USER AGENT for ChatGPT-User vs Browser: h1, words 0 -> 64. That's the whole trade in five rows. ChatGPT-User, the live fetcher, now reads the headline and 64 words. OAI-SearchBot, the crawler that builds ChatGPT search's index, still gets an empty . So does GPTBot, and so would PerplexityBot and Claude-SearchBot. A snapshot helps the fetch that happens after ChatGPT has already picked your page; it does nothing for the index it picks from. Two more things the toy makes obvious: Anyone can send that user agent. The routing trusts a header. On Wednesday 7 October 2026, 69% of the 404s logged under the ChatGPT-User user agent on small business websites in LovedByAI's logs were exploit probes, not ChatGPT. If you measure a snapshot's effect by counting requests under assistant names, check them against OpenAI's published IP ranges ( chatgpt-user.json , searchbot.json , gptbot.json ) first. A user-agent test only sees user-agent routing. If a CDN also checks the request's IP, bot_view.py will see the live page for every agent. That isn't proof nothing is switched. Is it cloaking to serve ChatGPT-User a snapshot? Not by Google's definition, while the snapshot matches the page. Google's dynamic rendering documentation says similar content isn't cloaking, and its example of cloaking is a page about cats for users and dogs for crawlers. The risk is drift: a snapshot that still shows last month's price isn't the same content as the live page any more. When bot_view.py reports DIFFERS BY USER AGENT , compare the two responses by hand. The same page warns that "dynamic rendering was a workaround and not a long-term solution." How do you fix SPA SEO for AI crawlers? Put the content in the HTML you send, for every visitor. Google recommends three ways to do that: Server-side rendering. Next.js, Nuxt, SvelteKit, Remix and Angular's SSR all render the first response on the server, then hydrate. Every crawler gets the text; nobody gets a different page. Static generation (prerendering at build time). For marketing pages, docs and anything that doesn't change per request, build HTML files. Astro, Next.js static export and Nuxt's generate mode all do this. It's the cheapest fix there is: the CDN serves files. Hydration of server-sent HTML , the general form of both: send real markup, then let JavaScript take over. If you can't change the app soon, serve a prerendered copy to every bot you care about, OAI-SearchBot, PerplexityBot and Claude-SearchBot included, not just the live fetchers. And give it an expiry: re-render on deploy and when prices or stock change, so the copy never drifts from the page. Whatever you pick, put bot_view.py in CI against a staging URL. It exits with 1 when anything is flagged: python3 bot_view.py https://staging.example.com/ https://staging.example.com/pricing A deploy that ships an empty shell, or a CDN rule that starts sending bots a different page, then fails the build instead of quietly costing you ChatGPT search. Where does WordPress fit? Mostly outside this problem. WordPress builds each page in PHP and sends finished HTML, so the headings, text and schema are in the first response. The exceptions are widgets that load after the page (some review carousels, booking and menu embeds) and headless WordPress with a front end that renders in the browser. By default, LovedByAI doesn't switch anything by user agent: people, ChatGPT-User, OAI-SearchBot and Googlebot get the same WordPress page at the same URL. Each page's machine-readable copy lives at its own public address (the page URL plus ?llm_view=1 ), linked from the site's footer with a plain HTML link, so any person or bot can open it. The full breakdown of dynamic bot rendering, with the pros, the cons and how it compares with prerendering and server-side rendering: https://www.lovedby.ai/blog/dynamic-bot-rendering For the business side, whether a small business should turn dynamic bot rendering on at all, see our analysis on Medium .

  • DEV CommunityThe Giantsread at source

    Daily Dose of DevOps — Platform product management: for secure self-service

    Platform product management: for secure self-service Enterprise reliability deteriorates when automation accelerates change without strengthening evidence. For platform product management for secure self-service , the decisive question is not whether a team can demonstrate the technology once. It is whether the organisation can operate it repeatedly, audit its decisions, and recover when assumptions fail. The operating problem Treat platform product management as part of a product-oriented internal platform with explicit service ownership and paved-road contracts. Define the consumer, owner, support boundary, change policy, and recovery objective before selecting implementation details. When operating platform product management for secure self-service, undocumented authority and ambiguous ownership create more risk than a missing feature. A credible design measures adoption, successful self-service completion, lead time, and platform-induced toil. Those measures should be visible to both the platform owner and consuming teams. If the measurements cannot distinguish adoption from coercion, or reliability from mere activity, the operating model is not yet falsifiable. A practical control Start with a narrow contract that can be tested automatically. The implementation should encode versioned golden paths, discoverable ownership, policy guardrails, and measured developer outcomes. The following fragment is illustrative; production values must be derived from workload evidence and organisational policy. apiVersion : backstage.io/v1alpha1 kind : Component metadata : name : payments-api annotations : platform.example/owner : payments spec : type : service lifecycle : production Roll the control out to one representative service, observe failure behaviour, and exercise rollback before broad adoption. Record exceptions as expiring decisions with an accountable owner, not permanent bypasses. Trade-offs Standardisation reduces cognitive load and makes controls observable, but an excessively rigid path displaces complexity into workarounds. Flexibility improves local fit, but every variant expands the support surface and weakens fleet-wide guarantees. For platform product management for secure self-service, prefer a small mandatory safety kernel surrounded by replaceable implementation choices. The organisation must also pay for operability. More validation increases feedback time; more telemetry increases cost and cardinality risk; stronger isolation can reduce utilisation. Make those costs explicit and compare them with the blast radius and recovery cost they buy down. What teams get wrong The recurrent anti-pattern is centralising delivery behind a ticket queue while calling the result self-service. Teams then measure task completion instead of production outcomes, accumulate exceptions without expiry, and discover during an incident that the nominal control has no tested recovery path. Another error is adopting a reference architecture without its assumptions. Validate identity boundaries, dependency failure, capacity pressure, partial rollout, rollback, and audit reconstruction in the environment that will actually carry production traffic. Key Takeaways Treat platform product management as an owned product and control system, not a tool installation. Design for the constraints captured by “for secure self-service”; document the authority, failure domain, and recovery objective. Measure adoption, successful self-service completion, lead time, and platform-induced toil. Automate versioned golden paths, discoverable ownership, policy guardrails, and measured developer outcomes. Test degraded operation and rollback before scaling adoption.

  • DEV CommunityThe Giantsread at source

    Does Your AI App Need All This Architecture?

    I came across a slide showing AI agent frameworks on a spectrum. Direct calls to a model sat at one end. At the other were tools with much more of the machinery already built in. In between: LangGraph, Strands, OpenAI Agents SDK, CrewAI, and plenty of others. My first thought was that it was a useful way to organize a crowded space. My second thought was that you could probably spend a week debating that slide without getting any closer to solving a customer’s problem. That’s the part that interests me. Not which framework wins, but how quickly choosing a framework can become the work. It’s a spectrum, not a promotion ladder There’s an easy mistake to make when looking at a diagram like this: assume that moving toward the more fully loaded end means you’re building something more advanced. It doesn’t. You’re mostly changing how much you build yourself and how many decisions the tool has already made for you. LangGraph, for example, is a low-level orchestration framework for stateful workflows and agents. It gives you considerable control. But “low-level” doesn’t necessarily mean less work for the person building the application. OpenAI’s Agents SDK takes a different approach, offering a small set of building blocks along with capabilities such as tool execution and tracing. Lightweight doesn’t have to mean bare-bones. Claude Agent SDK comes with the agent loop, tools, and context management behind Claude Code. For an application that needs those capabilities, starting with them already available could be the simpler choice. So I wouldn’t read that spectrum as “simple on the left, unnecessarily complicated on the right.” The useful question is how well each tool fits the work. A framework that makes decisions you agree with can save you a lot of effort. One that makes decisions you keep fighting may become another problem to maintain. Does this step really need an agent? Imagine a document-processing application. It receives a document, extracts a few details, checks them against business rules, and sends anything uncertain to a person. There’s a sensible role for AI here. Reading messy, inconsistent documents is very different from comparing a validated number against a fixed limit. Suppose the rule says anything above $5,000 needs approval. Once the amount has been extracted and checked, I’d rather let ordinary code enforce that rule. I don’t need the model to have an opinion about it. This is a useful distinction between a workflow and an agent: a workflow follows predefined paths, whereas an agent can let the model decide how to proceed. Neither approach is automatically better. They give the model different amounts of control. Now imagine turning that same application into a document-reading agent, a validation agent, a routing agent, and a supervisor agent. Maybe there’s a good reason. But before approving the design, I’d ask what each handoff improves. Accuracy? Speed? A clearer separation of responsibilities? “Because that’s how the framework’s example does it” wouldn’t be enough. Otherwise, we might have taken a fairly ordinary workflow and given it middle management. Writing everything yourself isn’t automatically better There’s an equally unhelpful response to all this: “Just use the API.” That sounds wonderfully simple until your application needs to pause for approval, preserve its progress, recover from failures, and show someone what happened. Frameworks such as LangGraph provide infrastructure for persistence and human intervention precisely because those needs are real. Refusing a framework on principle can leave you building your own version of one, except now your team owns every awkward corner of it. I’d compare the whole job, not just the first working demo. How much code will we maintain? How will we investigate a wrong answer? Can another engineer understand the execution without needing the original author beside them? A small application with a pile of homemade infrastructure isn’t necessarily simpler than one using a well-chosen framework. Likewise, adding more agents can trade extra time and cost for better results. That trade might be worthwhile, but it deserves to be tested rather than assumed. The question I’d ask is: does the more elaborate version perform well enough to justify what it adds? What are we rewarding? Picture two proposals in a design review. One describes an autonomous multi-agent platform with specialist roles and a supervisor. The other describes a controlled workflow with two model calls and a human approval step. Before seeing either one work, which sounds more innovative? I’d worry if the first proposal got an easier hearing simply because its vocabulary sounded more ambitious. That’s a leadership problem as much as an engineering one. The less glamorous questions are the ones I’d want answered. What happens when the model gets it wrong? Who can stop an action? What will the team be maintaining six months from now? What evidence would convince us to remove a component? None of those questions rules out a sophisticated agent system. They just ask it to earn its place. I’m happy to use a framework that saves the team work. I’m also happy to build a small workflow that never needs one. I don’t see either choice as a statement about how serious we are about AI. But I do think we should notice when someone makes a system smaller without making it less useful. If an engineer removes three agents and the application becomes easier to understand, test, and operate, that should count as progress. Even if the architecture diagram looks less impressive afterward.

  • DEV CommunityThe Giantsread at source

    Buried Reads #1: Five Good Posts That Deserve More Attention

    My own posts on DEV have ranged from a few hundred views to a few thousand, and I can't always tell you why. It's rarely the writing. It's the hour you hit publish, the title, the tags, and whether anyone happened to be scrolling. That bugs me, because the posts that sink are sometimes the ones I would most have wanted to read. So this is a new series. I dig through near-zero-engagement posts on DEV, read the ones that look real, and share the best here. The rules Almost no engagement. Zero or close to zero reactions and comments. Counts checked as of Oct 17, 2026. I read it first. Every post on this list was read start to finish before it earned a spot. No skimming, no vibes-only picks. No hidden pitch. If an author links their own project, I say so. If someone approached me, I say that too. No money changes hands. No sponsored slots, no paid mentions, and no affiliate kickbacks. If someone offers to pay for a spot, the answer is no. 1. High-Performance .NET: Reducing Garbage Collector Overhead by Cutting Allocations By @alexey_popov High-Performance .NET: Reducing Garbage Collector Overhead by Cutting Allocations Alexey Popov Alexey Popov Alexey Popov Follow Sep 16 High-Performance .NET: Reducing Garbage Collector Overhead by Cutting Allocations # dotnet # aspnetcore # performance # latencyspikes Add Comment 10 min read What it's about: GC pauses mostly come from how much you allocate, so the fix is to allocate less. Which tool you reach for depends on how long the data needs to live: stack allocation, spans, or one of the pools. Why it's worth your time: It points to real places in the .NET 10 and ASP.NET Core 10 source where these techniques are used, instead of toy examples. It's also upfront about how each one can bite you, from stack limits to returning pooled arrays properly, and it keeps reminding you to measure first. What's missing: Benchmark numbers. It explains the techniques well but never shows what they save. Read it if: You've used pooling because someone told you to and never quite knew when it pays off. 2. VideoFloppy: Five Years, Ten Users, One Dollar By @mgebrov VideoFloppy: Five Years, Ten Users, One Dollar Giorgi Mgebrishvili Giorgi Mgebrishvili Giorgi Mgebrishvili Follow Aug 30 VideoFloppy: Five Years, Ten Users, One Dollar # sideprojects # blazor # dotnet # programming Add Comment 5 min read What it's about: A site for saving and sharing videos hosted elsewhere, started in 2021 after a study tool the author relied on shut down. He built it in spare hours alongside two jobs. Five years in, it has a few dozen users, almost no traffic, and one paying customer who paid a dollar. Why it's worth your time: There's no spin. He says plainly that it was never meant to make money, then lists what it gave him instead: practical lessons he now uses at work, like handling client IP addresses in Blazor Server. Heads-up: The post links to the product, since the product is the subject. There's no sales push. Read it if: You've built something nobody uses and wondered whether it was worth it. 3. I measured silence: 212,390 outside pull requests across 11,000 GitHub projects By @pctablet505 I measured silence: 212,390 outside pull requests across 11,000 GitHub projects Rahul Kumar Rahul Kumar Rahul Kumar Follow Oct 15 I measured silence: 212,390 outside pull requests across 11,000 GitHub projects # github # career # opensource # programming 1 reaction 3 comments 3 min read What it's about: The author tracked six months of pull requests from outside contributors and checked one thing: did a human reply, review, or merge within two weeks? Bots, maintainers' own PRs, and drafts were excluded. He reports that about a quarter of the active, licensed projects with ten or more outside PRs left most of them unanswered for those two weeks, and that the share climbs with star count: 1k–10k stars: ~21% 10k–50k stars: ~31% 50k+ stars: ~39% Why it's worth your time: It puts numbers on something every first-time contributor suspects. It also states its own limits: it isn't a verdict on maintainers, it only covers GitHub, and it's a snapshot. Heads-up: The account is new (joined in September), the post links to the author's own free ranking site, and the figures are his own. I haven't verified them, so treat this as a good question with a plausible answer rather than settled fact. Read it if: You're about to send your first open-source PR and want to know where it's likely to get a response. 4. Why your SQLite WAL file never shrinks By @nobody_4fb7fd10637d3b88a3 Why your SQLite WAL file never shrinks Nobody Nobody Nobody Follow Sep 25 Why your SQLite WAL file never shrinks # sqlite # database # internals # benchmarks Add Comment 12 min read What it's about: You run SQLite in WAL mode with active readers and writers, autocheckpoint is enabled, and PRAGMA wal_checkpoint reports success—yet the -wal file balloons to multiple gigabytes next to a tiny database. The problem: when overlapping read transactions mean at least one reader is always open, checkpointing can never complete its cycle back to frame 1. Why it's worth your time: Instead of paraphrasing documentation, the author traces the checkpoint logic directly in SQLite's wal.c , then spins up a lab to benchmark what happens. Under a 2,000 commit/s writer with overlapping readers, the WAL grew by 11.9 MiB/s and stayed at 357 MiB even after readers disconnected. It walks through what PRAGMA wal_checkpoint(TRUNCATE) actually does and the writer-stall trade-offs it causes. What's missing: The benchmarks simulate an aggressive, continuous write loop. In lower-traffic or batch-style setups, you won't hit this edge case as quickly. Read it if: You use SQLite in production (with tools like Litestream, PocketBase, or embedded web backends) and have ever wondered why WAL files refuse to reclaim disk space. 5. Fix Truncated Node.js Stack Traces: Error.stackTraceLimit By @doogal Fix Truncated Node.js Stack Traces: Error.stackTraceLimit Doogal Simpson Doogal Simpson Doogal Simpson Follow Oct 15 Fix Truncated Node.js Stack Traces: Error.stackTraceLimit # node # javascript # debugging # softwareengineering Add Comment 4 min read What it's about: You get an unhandled rejection in Node.js, open the stack trace, and find only internal library code, with your own file name and line number nowhere in sight. The cause is V8's default limit of 10 stack frames, and between middleware, ORMs, and async wrappers, those 10 frames get used up before they reach your code. Why it's worth your time: It explains the why behind a frustration most Node.js developers have felt, then gives the one-line fix ( Error.stackTraceLimit = 50 or the --stack-trace-limit flag). The camera-with-10-exposures analogy makes the default easy to understand. What's missing: It doesn't cover the performance cost of raising the limit in production, which is the main reason you wouldn't just set it to Infinity . Read it if: You've ever stared at a stack trace that stopped right before the useful part. Your turn 🗣️ Read something recently that deserved more attention than it got? Drop the link in the comments with one line on why. I'll read the ones that fit the rules above and feature the best in the next issue.

  • DEV CommunityThe Giantsread at source

    SlothCloset

    This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady What I Built Every morning starts with the exact same low-level friction: standing half-awake in front of an open wardrobe, suffering from choice paralysis, and burning mental energy trying to figure out if an olive cargo pant clashes with a navy jersey tee or if your favorite hoodie is still in the laundry basket. SlothCloset Studio ( SLOTHCLOSET_OS ) is an offline-first, open-weight wardrobe deck-builder that treats your closet like a Clash Royale deck-building constraint graph. Designed for anyone who wants to automate their daily routine and be unapologetically lazy before their morning coffee, SlothCloset eliminates morning decision fatigue in under a millisecond: 🃏 Weekly Wash-Cycle Rotation Solver (3–7 Days): Computes a complete week of non-overlapping outfits in ~0.5ms to 2.0ms . It automatically enforces a configurable 1–3 day laundry/rest cooldown on tops and bottoms while allowing daily staples like watches and sneakers to rotate naturally. 🔒 Standalone Outfit Synthesizer (Lock / Ban Veto): Want to wear one specific hoodie today and let math figure out the rest? Lock any garment in place (or veto items you aren't in the mood for), choose a meta style archetype ( Standard Meta , Monochrome Beatdown , Earth-Tone Cycle , or High-Contrast Aggro ), and synthesize high-synergy combinations with built-in anti-clone rotation. 🎨 Multi-Color Swatch & Cutout Pipeline: Supports multi-color garments (up to 3–4 HEX swatches per piece), strips messy bedroom backgrounds locally using open-weight rembg (U2Net) , or fetches clean studio flat-lay catalog twins via SerpApi . 🧠 Tactical AI Stylist & "5th-Card Unlock": Powered by Google Gemma 2 ( gemma2:2b ) , an optional non-blocking AI analyst writes concise synergy breakdowns for any drafted outfit and recommends a single missing wardrobe piece to unlock new combinations—complete with a live product visual pulled via SerpApi. Demo 🚀 Live Cloud Deployment (24/7): https://sloth-closet12999.streamlit.app/ Studio UI Walkthrough ( SLOTHCLOSET_OS ) 00. Minimalist Landing Index: 01. Outfit Planner & Archetype Engine: Standalone Outfit Builder (Force-Lock & Ban/Veto Controls): Weekly Rotation Matrix (3–7 Day Wash-Cycle Solver): 02. Wardrobe Asset Repository (Clean / Laundry / Skip States): Code p-rth12999 / Sloth-CLoset An offline-first, open-weight wardrobe deck builder that automates your daily outfit choices so you never have to stand in front of your closet stressing out again. 🎯 The Problem Every morning comes with the exact same friction: staring into a dark wardrobe, suffering from choice paralysis, and wasting mental energy trying to figure out what pants go with what shirt. Existing wardrobe apps are bloated, invasive, and require sending personal photos of your clothes and room to third-party cloud servers. 💡 The Solution: SlothCloset Studio Inspired by Clash Royale deck-building systems and RoyaleAPI asset management, SlothCloset treats your wardrobe like a card game deck. It lets you build a Weekly Outfit Rotation in under a millisecond using offline heuristic math, features a Ban/Skip List Veto, handles Wash-Cycle Cooldowns, and leverages Google Gemma 2 (via Ollama) for deep local AI styling advice. ✨ Key Features 🃏 RoyaleAPI-Style Weekly Rotation: Automatically plans 3 to 7 days of unique non-overlapping outfits at once. ⚡ Sub-Millisecond Python Heuristic Graph: Zero-LLM latency for the core color-matching engine (~0.5ms compute time). 🧺… View on GitHub (Fallback Repository Link: https://github.com/p-rth12999/Sloth-CLoset ) How I Built It Early in development, I realized a major trap with AI-first apps: if you put an LLM directly in the critical path of generating a 7-day outfit rotation, the user has to stare at a loading spinner for 10+ seconds just to pick a t-shirt. That isn't "lazy"—that's annoying. Instead, I architected SlothCloset around a Hybrid Heuristic + Local Open-Weight AI pipeline: Sub-Millisecond Python Constraint Graph ( 0.001s Core): Every clothing card stores up to 3 dominant HEX codes alongside its category ( Top , Layer , Bottom , Footwear , Accessory ), laundry state, and ban status. Using RGB luminance and HSV saturation math, the engine classifies swatches into color families ( neutral_dark , neutral_light , neutral_grey , earth , warm_pop , cool ) and scores pairwise color harmony against meta_rules.json archetypes. For standalone builds, an anti-clone diversity penalty tracks recently drafted items on screen so every click of + Generate New Outfit rotates fresh combinations without repeating the same jacket or jeans. Open-Weight Local AI ( Google Gemma 2 via Ollama & rembg U2Net): Google Gemma 2 ( gemma2:2b via Ollama): Rather than blocking the UI, Gemma 2 acts as an on-demand Tactical Stylist. When triggered on any outfit card, it evaluates the drafted combination in structured JSON mode, explains why the color contrast works, and identifies a "Missing Asset" that would bridge the user's current closet. Open-Weight Vision ( rembg / U2Net + Pillow Mediancut): When uploading a raw photo of a garment locally, rembg strips the background entirely on-device, and Pillow quantizes the remaining opaque pixels to automatically extract the garment's top 3 HEX color swatches. Dual-Runtime Frontend & Data Layer: Local Studio SPA: Built with FastAPI , Tailwind CSS , and Alpine.js in a stark dark-mode developer aesthetic inspired by Andrej Karpathy's minimalist tooling and Superdesign. Cloud Twin: Wrapped the exact same heuristic engine and database layer into Streamlit so anyone can test the solver 24/7 in the browser. Persistence & Visuals: Backed by MongoDB Atlas (with automatic local JSON fallback for 100% offline resilience) and SerpApi Google Images to pull clean flat-lay catalog visuals for wardrobe items and Gemma 2's shopping recommendations. Why Does Open Innovation Matter? Your wardrobe—and photos of your bedroom, laundry, and daily habits—is deeply personal data. Existing "smart closet" apps are bloated SaaS subscriptions that force you to upload personal photos to proprietary cloud buckets and pay per API call just to organize your own clothes. Open innovation made three critical things possible for SlothCloset that a closed API couldn't: Zero-Telemetry Privacy: By combining local Ollama ( gemma2:2b ) with open-weight rembg (U2Net) , photos of your clothes and your daily styling queries never have to leave localhost . Zero-Cost Infinite Experimentation: A student or indie developer shouldn't have to worry about token billing every time they re-roll their weekly outfit schedule. Open weights let you run tactical styling analysis as many times as you want for $0.00. Hackable Rulesets: Because the color-harmony matrix ( meta_rules.json ) and constraint solver are completely transparent Python code rather than an opaque black-box prompt, anyone can fork the repo and tune the weights for their own local climate, uniform rules, or personal aesthetic. The Lazy Payoff Let's do the lazy math: Spending 4 minutes every morning debating what to wear—or realizing your go-to shirt is still in the wash—costs nearly 30 minutes a week (over 24 hours a year ) of pure decision fatigue before 8:00 AM. With SlothCloset Studio , I spend 10 seconds on Sunday night clicking Generate Weekly Plan (or 1.08 ms locking in a single shirt on a random weekday morning) to get a pre-validated, color-matched rotation that already respects my laundry cycle. I used it all week while building this submission: locking in my Colorblock Zip Hoodie for a chilly morning commute and letting the engine automatically pair it with Olive Relaxed Cargos and Court Sneakers without me having to think twice. My Agent Session SlothCloset Studio: deterministic outfit synthesis and Gemma stylist You Inspect SlothCloset Studio's main.py, streamlit_app.py, and meta_rules.json. Summarize how the sub-millisecond Python color-harmony heuristic engine, wash-cycle cooldown solver, and local Ollama Gemma 2 stylist work together. Agent Inspected the three requested artifacts without transmitting secrets or private machine paths. The project has a deterministic scoring layer, a cooldown-aware weekly planner, and an optional local Ollama enrichment layer. ▸ workspace_inspection main.py; streamlit_app.py; meta_rules.json Input main.py; streamlit_app.py; meta_rules.json Output Found color-family classification, pairwise harmony scoring, archetype modifiers, standalone outfit enumeration, weekly availability/cooldown scheduling, UI timing instrumentation, and an Ollama Gemma 2 JSON analysis endpoint. Agent The heuristic engine classifies HEX colors into neutral_dark, neutral_light, neutral_grey, earth, warm_pop, or cool. It averages configured pairwise family scores from meta_rules.json, applies archetype-specific boosts/penalties and vibe bonuses, adds a deterministic ID tie-breaker, and clamps the result. Standalone generation enumerates valid category combinations, honors locked/excluded items, ranks by harmony minus recent-item repetition penalties, and returns the best distinct build. Agent The weekly solver receives only clean, unbanned items, builds a 3–7 day plan, and tracks last-worn day plus wear count. Tops obey the selected wash/dry cooldown; bottoms and layers require more than one day rest; footwear and accessories can recur daily. Each day's candidate combinations are scored by the same harmony engine and adjusted for freshness, with deterministic fallback picks when the eligible pool is exhausted. Agent The local Ollama Gemma 2 stylist is an optional second-stage explainer, not the constraint solver. The app sends the selected cards and archetype to localhost Ollama using a configurable local model (default gemma2:2b), requests strict JSON, and asks for a concise battle strategy plus one wardrobe unlock recommendation. The response is sanitized/parsing-guarded and paired with an optional SerpApi visual; if Ollama fails, a local deterministic fallback explanation is returned. Agent The Streamlit surface times solver calls with perf_counter and displays the plan, scores, palettes, cooldown/reuse badges, and optional Gemma analysis. meta_rules.json is the data-driven policy layer: base score, color families, pairings, and balanced/monochrome/earth/contrast archetype descriptions. 6 of 6 messages During my agent-assisted build sessions, we iterated through three major architectural pivots for SlothCloset Studio : Moving the LLM out of the critical path: We pivoted from slow LLM outfit generation to a deterministic Python RGB/HSV constraint solver ( score_outfit_combo ), keeping Google Gemma 2 ( gemma2:2b ) as an asynchronous Tactical Stylist. Solving the "Single-Item Clone" bottleneck: When early standalone builds kept repeating the same hoodie and sneakers, we expanded the closet to 16 multi-swatch assets and implemented an anti-clone diversity penalty that tracks recently drafted items on screen. Dual-Runtime Packaging: We paired the minimalist dark-mode FastAPI + Alpine.js local studio UI with a 24/7 Streamlit Cloud twin backed by MongoDB Atlas and SerpApi. Prize Categories Best Use of Gemma: Uses Google's open-weight Gemma 2 ( gemma2:2b ) model via Ollama (with cloud fallback support) in structured JSON output mode to generate on-demand outfit synergy critiques and "5th-Card Unlock" wardrobe upgrade recommendations. Best Use of MongoDB Atlas: Persists multi-color wardrobe documents, live laundry states ( is_clean ), and veto flags ( is_banned ) in a MongoDB Atlas cluster with seamless local JSON fallback for offline-first reliability. Best Use of SerpApi: Uses the SerpApi Google Images API in two ways: (1) converting text descriptions of clothes into clean, isolated "Studio Twin" flat-lay product visuals for the closet grid, and (2) fetching real-time shopping visuals and inspection links for Gemma 2's recommended missing wardrobe items.

  • HeyDesignerDeveloper/Designer Newsread at source

    Behind Apple Music’s new brand identity

    Flow in UX, The default wins, You could do it alone.

  • freeCodeCamp.orgYouTube ChannelsVideoWatch on YouTube

    MCP Security Fundamentals Course

  • Wes BosYouTube ChannelsVideoWatch on YouTube

    How to 3D Model your entire house

  • Hacker News Front PageThe Giantsread at source

    Amazon identifies Oct 17 PHP2Shell exploitation prior to public disclosure

  • Hacker News Front PageThe Giantsread at source

    Xbox wants you to pay 24 to 40 cents per hour to stream games you bought

  • Hacker News Front PageThe Giantsread at source

    Several Linux kernel vulnerabilities accidentally posted to public mailing list

  • Flavio CopesMore Front-end Bloggersread at source

    AI video editing tools: what agents need to work safely

    Recording and editing tools need inspectable state, useful commands, and recoverable changes if we want agents to help with real creative work.

  • Hacker News Front PageThe Giantsread at source

    Faster than earcut: triangulating 3.7M map polygons in 489 ms

  • Hacker News: Show HNLibraries, Frameworks, etc.read at source

    Show HN: Tinytowns, a small model to generate realistic sounding town names

    Comments

  • Hacker News Front PageThe Giantsread at source

    CVE-2026-111943: Compromised Intermediate Certificate Authority

  • Flavio CopesMore Front-end Bloggersread at source

    A deep dive into Claude Duet

    Claude Duet is Anthropic's proactive cloud agent. Learn how it works, what it can access, and how it compares with Grok Bot and ChatGPT dots.

  • Hacker News: Show HNLibraries, Frameworks, etc.read at source

    Show HN: Aw-1 – Deterministic AST circuit breaker and kernel jail for AI agents

    Comments

  • Flavio CopesMore Front-end Bloggersread at source

    Paid traffic for SaaS validation: how to test product demand

    How to use a small paid traffic experiment to learn who gets value from a product, measure useful actions, and decide what to change.

  • Hacker News: Show HNLibraries, Frameworks, etc.read at source

    Show HN: Cathode, a Gtk4 YouTube player based on mpv and yt-dlp

    Comments

  • Hacker News: Show HNLibraries, Frameworks, etc.read at source

    Show HN: HN Sieve – every Show HN scored and summarized by AI

    Comments

  • AbduzeedoMulti Author Blogsread at source

    Packaging Design: Tenderleaf Botanical Care by Svetlana Kalinova

    Explore the Tenderleaf botanical skincare packaging design and brand identity by Svetlana Kalinova, pairing serif type with frosted glass. Skincare shelves are usually loud. Walk down any beauty aisle...

  • Hacker News: Show HNLibraries, Frameworks, etc.read at source

    Show HN: Twine is a meta-harness with workflows, cross-agent memories and traces

    Comments

  • Chris HawkesYouTube ChannelsVideoWatch on YouTube

    Where Programmers Go From Here

  • AbduzeedoMulti Author Blogsread at source

    Book: Daring Forever by Radim Malinic

    Radim Malinic's new book Daring Forever argues that courage, curiosity and creativity are human capacities buried in all of us. Daring Forever begins at the edge of something: a blank page, a stage, a...

  • Google for DevelopersYouTube ChannelsVideoWatch on YouTube

    🔊 Voice design and voice replication with Gemini 3.8 Flash TTS

  • AbduzeedoMulti Author Blogsread at source

    Alleima: Inside Kurppa Hosk’s Visual Identity

    Explore the Alleima visual identity by Kurppa Hosk, pairing Molten Orange and Dark Steel Blue with Alleima Neurial typography for global steel. Heavy industry rarely gets good design. When Sandvik dec...

  • DigitalOcean BlogMulti Author Blogs10 min read

    Critical PHP RCE Vulnerabilities: Patch Now (CVE-2026-109618, CVE-2026-109619)

    DigitalOcean is aware of two critical remote code execution (RCE) vulnerabilities in PHP, tracked as CVE-2026-109618 and CVE-2026-109619 , publicly disclosed on October 21, 2026. Either allows an attacker to execute arbitrary code on a server running PHP, potentially resulting…

  • SitePointThe Giantsread at source

    Building Accessible Navigation Menus with HTML, CSS, and JavaScript

    null Continue reading Building Accessible Navigation Menus with HTML, CSS, and JavaScript on SitePoint .

  • AdactioTop Front-end Bloggersread at source

    Wednesday session

  • AbduzeedoMulti Author Blogsread at source

    The i Paper Digital Experience Finally Feels Like Its Journalism

    ustwo rebuilt the i Paper Digital Experience around impartial news and intelligent debate, made to feel active, premium and energising. Most news apps look the same: a grey feed, a blue link, a red br...

  • AbduzeedoMulti Author Blogsread at source

    Humbleteam Unveils Podium UI/UX Design & Web System

    Explore the Podium UI/UX design and brand system by Humbleteam, built around a Pantone 185 red spotlight motif and modular interface cards. Performance marketing usually drowns in noisy dashboards. Hu...

  • Google for DevelopersYouTube ChannelsVideoWatch on YouTube

    Design and replicate voices with Gemini 3.8 Flash TTS

  • Jim Nielsen’s BlogMore Front-end Bloggersread at source

    No Need for Retirement When Utopia Is Around the Corner

    I’ve mentioned before my interest in the history and development of nuclear weapons . Currently, I’m reading The Doomsday Machine: Confessions of a Nuclear War Planner by Daniel Ellsberg (of Pentagon Papers renown). In the first chapter, Ellsberg talks about his time working at the RAND Corporation during the missile gap years when the U.S. thought it was falling behind the Soviet Union in nuclear capabilities. Many of his descriptions sound strikingly similar to the rhetoric coming out of places like Anthropic. For example, note the religious overtones of working at a corporation: I loved RAND, where I ended up spending ten years [...] Much, I imagined, like members of a religious order would, I shared with my colleagues a sense of brotherhood, living and working with others for a transcendent cause. They were insiders : burdened with the responsibility of knowledge others did not possess. precisely in my early missile-gap years at RAND and as a consultant in Washington, there was our sense of mission, the burden of believing we knew more about the dangers ahead, and what might be done about them, than did the generals in the Pentagon or SAC, or Congress or the public, or even the president. It was an enlivening burden. And what was their “enlivening burden”? Saving the world: [My colleagues] shared a feeling—soon transmitted to me—that we were in the most literal sense working to save the world. What really stood out was this part, where Ellsberg describes how he and his colleagues truly believed the end was nigh: From the Air Force intelligence estimates I was newly privy to, and the dark view of the Soviets, which my colleagues shared with the whole national security community, I couldn't believe that the world would long escape nuclear holocaust. Alain Enthoven and I were the youngest members of the department. Neither of us joined the extremely generous retirement plan RAND offered. Neither of us believed, in our late twenties, we had a chance of collecting on it. This reminds me of the report that AI researchers have taken up smoking as a way to signal their belief that AI will cure cancer before smoking kills them. At this point, I wouldn’t be surprised to hear a lab like Anthropic announce they’re discontinuing all employer-sponsored retirement benefits. It’d be a small sacrifice on behalf of the employees to demonstrate their faith that universal high income is just around the corner. (The corporate cost savings would just be a nice bonus.) Reply via: Email · Mastodon · Bluesky

  • Flavio CopesMore Front-end Bloggersread at source

    Security in the age of AI

    AI agents are finding old vulnerabilities and making complex attacks easier. A short history of automated hacking, what comes next, and how to prepare.

  • AdactioTop Front-end Bloggersread at source

    Patched my PHP within minutes of the update being released; super-smooth with no problems.

  • SitePointThe Giantsread at source

    CORS Error Fix: Diagnose Console Errors and Configure Headers

    Diagnose browser CORS errors from console messages and preflight responses, then apply secure fixes using development proxies or server-side headers in Express, Next.js, and Nginx. Continue reading CORS Error Fix: Diagnose Console Errors and Configure Headers on SitePoint .

  • SitePointThe Giantsread at source

    Prompt Caching API Example: Cut Token Costs in Node.js

    Structure stable prompt prefixes across OpenAI, Anthropic, and Gemini, then verify cache hits with each provider's usage metrics in Node.js. Continue reading Prompt Caching API Example: Cut Token Costs in Node.js on SitePoint .

  • SitePointThe Giantsread at source

    Check if eMudhra CA Is Still Trusted in Your Runtime

    Audit runtimes for the eight compromised eMudhra intermediate CAs using the official per-chain test endpoints and chains.zip, then update every trust store. Continue reading Check if eMudhra CA Is Still Trusted in Your Runtime on SitePoint .

  • AbduzeedoMulti Author Blogsread at source

    Studio Sonda Unveils the Living Wine Label for Piquentum

    Studio Sonda made a living wine label from the wine's own lees sediment, so noble mould keeps growing on it and no two bottles look alike. The label is a rough band of sediment paper wrapped straight ...

  • Flavio CopesMore Front-end Bloggersread at source

    Give your coding agent a state machine

    Build a small JavaScript state machine for a coding agent, with explicit transitions, a retry limit, a useful event log, and tests.

  • DigitalOcean BlogMulti Author Blogs10 min read

    Product Security in the Post-AI Era

    AI hasn’t changed what secure software looks like, but what has changed is almost everything about how software gets built. Security programs designed around old processes are anchored to points on a lifecycle that no longer exist. Last month, DigitalOcean’s Product Security…

  • Go Make ThingsMulti Author Blogs3 min read

    The SpeechRecognition API

    There’s an older deaf gentleman in my town who’s very friendly, and likes to communicate with rudimentary hand gestures, but I have a hard time understand what he’s trying to say. I’d love to learn American Sign Language (ASL) at some point (shoutout King Ron), but until then, I wanted an app that could convert speech into text. Every transcription app I found required a pretty expensive subscription… so I decided to build my own using web technologies!

  • DequeMulti Author Blogs7 min read

    Debunking AI agent accessibility claims and solving AI alignment for accessibility

    There is a digital accessibility approach that gives us the best of both worlds: the reliability and predictability of rules-based testing and the velocity of AI-powered automation. By taking this approach, we can close the gap between presumed and actual accessibility. The post Debunking AI agent accessibility claims and solving AI alignment for accessibility appeared first on Deque .

  • SitePointThe Giantsread at source

    Working With a Marketing Agency: A Technical Guide for Developers and Designers

    null Continue reading Working With a Marketing Agency: A Technical Guide for Developers and Designers on SitePoint .

  • SitePointThe Giantsread at source

    Build a Reliable Analytics Pipeline Before Moving to a Data Warehouse

    null Continue reading Build a Reliable Analytics Pipeline Before Moving to a Data Warehouse on SitePoint .

  • AbduzeedoMulti Author Blogsread at source

    Graphic Design: SIPF by Foreign Policy Design

    Explore the graphic design for the Singapore International Photography Festival by Foreign Policy Design, built around a shutter-split grid. Photography doesn't happen in a vacuum. When Foreign Policy...

  • Flavio CopesMore Front-end Bloggersread at source

    PSA: update PHP today

    PHP security fixes are available. Update now, check the fixed versions, and use these temporary mitigations only while waiting for patched packages.

  • Flavio CopesMore Front-end Bloggersread at source

    Jev vs structured outputs: when to use each

    Compare Jev, JSON mode, and schema-constrained LLM outputs. Learn when a typed answer is enough and when decision probabilities justify another model.

  • SitePointThe Giantsread at source

    How I Built a CRM with Vibe Coding Instead of Spending $1,000+ on App Builders

    null Continue reading How I Built a CRM with Vibe Coding Instead of Spending $1,000+ on App Builders on SitePoint .

  • CSS WizardryTop Front-end Bloggersread at source

    Web-Perf Wednesday 014 – Performance Budgets Need a Representative Worst

    Performance budgets need a representative worst, while Safari changes identity resolution and Chrome improves module recovery and memory debugging.

  • SyntaxPodcastsAudioListen

    1049: WTF is a Software Factory?

    Scott and Wes talk with Adam Jacob about software factories: what they actually are, why they’re unique to each team, and how to build trust in agent-generated code. They dig into Swamp Club, black box testing, domain driven design, adversarial review for accessibility, and…

  • freeCodeCamp.orgYouTube ChannelsVideoWatch on YouTube

    PostgreSQL Hybrid Search Course – Keyword (BM25) + Vector Retrieval

  • Flavio CopesMore Front-end Bloggersread at source

    Vite toolchain: Cloudflare, vinext, and shared web tooling

    Vite is becoming shared infrastructure for frameworks, runtimes, and developer tools. What vinext, Cloudflare's new tooling, and DevTools show.

  • W3C NewsBrowsers, engines, etc.1 min read

    W3C and the State of the Web in the AI Era

    This W3C paper from the Strategy Team is intended to foster discussion in the technical community at TPAC — the most important W3C community event of the year — about how the W3C technical agenda for the web needs to evolve based on the rise of AI agents. It is part of building a consistent, coherent shared vision for evolving the web, starting with AI.

  • HeyDesignerDeveloper/Designer Newsread at source

    Design and engineering are the same thing (video)

    Scaling the design process, Everyone is starting over, On alignment that looks wrong, The future of CSS.

  • W3C BlogBrowsers, engines, etc.3 min read

    Web of Things Working Group recharter: New momentum for IoT interoperability

    The Web of Things (WoT) Working Group rechartered for two years to improve IoT interoperability and address physical AI use cases. WoT counteracts fragmentation in IoT by providing building blocks that enable seamless device integration across smart buildings, industrial automation, and energy management. Drawing on Plugfest insights, the new charter focuses on enhancing Thing Description expressiveness, introducing protocol bindings, and guiding AI agents.

  • Robin WieruchMore Front-end Bloggersread at source

    Testing AI-Generated Code: Lint the Pattern, Test the Decision

    Testing AI-generated code without the noise: lint the patterns coding agents follow, share one test harness, and add tests only where a file leaves its pattern.

  • SitePointThe Giantsread at source

    Vibe Coding to Production: A Developer’s Checklist for Building Reliable Web Apps

    null Continue reading Vibe Coding to Production: A Developer’s Checklist for Building Reliable Web Apps on SitePoint .

  • AbduzeedoMulti Author Blogsread at source

    Visual Identity: Montreal Jazz Festival Concept

    A bold visual identity concept for Montreal Jazz Festival pairs generative TouchDesigner trumpet forms with agile jazz typography. Designing for an institution like the Montreal Jazz Festival means gr...

See everything from the last 30 days →