Today
Front-end, in one read.
The latest from the sources worth following, newest first.
DEV CommunityThe Giantsread at source
What Building a Ten-Page Static Notes Site Taught Me About Thin Content
I built a small static site this week: ten pages, plain HTML, one CSS block, deployed straight to Cloudflare Pages. The topic was something I actually do every morning, a daily music puzzle, and the pages were notes about it. It took an afternoon and the whole thing weighs less than a medium-sized blog post. It also taught me more about "thin content" than any SEO article I have read. 300 words is a floor, not a target My first drafts were around 180 words each. They read fine in isolation and they were useless as a set, because none of them said anything that needed a page. Rewriting to roughly 320-360 words forced a structure: a claim, a concrete example, a counter-example, and a closing that connects to the next note. The word count was not the point. The point was that the extra length came from specificity, not from padding. If you cannot get to 300 words of specifics about a page topic, that is a strong signal the topic is not a page. Merge it into the index, or delete it. Voice is the difference between notes and filler The pages that worked were the ones written in first person with an actual opinion: "I turn the volume down before the first clip because loud playback hides the bass, and the bass is where the era lives." The pages that felt thin were the ones written in a neutral explainer voice. Thinness is not a word-count problem, it is an ownership problem. If the page could have been written by anyone with a search engine, it probably should not exist. Link out to the thing you are writing about This sounds obvious and it is where most small sites get weird. If the subject of your notes is a thing that lives somewhere on the web, link to it. The site I was writing about is a daily music puzzle at https://songlessanswers.com/ ; every page in my notes site points there, not to pump a number but because the reader needs the thing itself to make sense of the note. At the same time, keep internal links honest. My index lists every page and every page links back. That is the entire information architecture and it took four lines of template code. The boring checklist still matters Canonical URL on every page, robots.txt with a sitemap, a sitemap that matches the real URLs, a title under 60 characters, a meta description that says something true, and no accidental noindex when you deploy to a preview URL. I got the last one wrong on the first deployment and the fix was one line of config. The whole checklist is ten minutes of work and it is the difference between a real site and a folder of files. Ship the small thing The reason to build ten pages instead of forty is that ten pages is finishable in one sitting, and a finished small site beats an unfinished big one every time. Mine is live, indexed, and does exactly two things: it collects the notes and it sends readers to https://songlessanswers.com/ to play. If you are waiting to build something big, build the ten-page version first. The constraints are a feature. Notes from a player of a daily music puzzle.
DEV CommunityThe Giantsread at source
From March 15, 2027, TLS certificates last 100 days: a checklist for agencies and hosts
If you run websites for other people, one date matters more than most this year: March 15, 2027 . The CA/Browser Forum voted to shorten the maximum lifetime of public TLS certificates in three steps: From Maximum validity Today (since March 15, 2026) 200 days March 15, 2027 100 days March 15, 2029 47 days The proof of domain control that a certificate authority accepts is shortened too, down to 10 days in 2029. In practice: a certificate that someone renews by hand once a year will start throwing "Your connection is not private" at visitors, and the hand-renewed ones are the ones nobody remembers until they fail. Why this hits agencies and hosts first One forgotten certificate is an incident. A portfolio of 80 client sites, each with its own host, DNS provider and renewal method, is a monthly source of tickets. The rule does not break the automated sites. It breaks the exceptions: the old VPS, the client who bought a certificate on their own, the mail server, the staging site that became production. A checklist you can run this week List every certificate you are responsible for , not only the websites: www and apex, API hostnames, mail servers (SMTP and IMAP certificates expire too), admin panels, anything behind a load balancer or CDN. Mark how each one is renewed. Automatic (ACME with certbot, acme.sh, Caddy, your host's panel) or by hand. Every "by hand" is a ticket waiting to happen in 2027. Move the manual ones to ACME. With DNS-01 validation you also cover wildcards and servers that cannot open port 80. Check that renewal actually reloads the service. A new certificate on disk that nginx or Apache never reloaded is the classic failure behind "it renews but the site still shows the old one". Decide who is alerted when a renewal fails , and on which channel. An e-mail to a mailbox nobody reads is not an alert. Look at the expiry dates from the outside , the way a visitor sees them, not from your own configuration. What your server says and what the internet sees can differ (wrong certificate on a CDN, a forgotten copy on another IP). Re-run the check after every migration : DNS change, new host, new CDN. The point of external checks Everything above is about your configuration. The only thing that matters to the visitor is what is served on the public internet. A free external check takes seconds: type a domain and read the expiry date, the issuer and the chain. I built one at AttackScout (free, no account): https://attackscout.com/en/tools/ssl-certificate-check?utm_source=devto&utm_medium=article&utm_campaign=cert-100-days . It shows the expiry date and the days left. Daily monitoring of a portfolio, with an alert before each expiry, is the paid part. Any monitoring tool that checks from the outside does the same job; the important thing is that someone checks. What to do now You have until March 2027. Start with the inventory: it is the step that always reveals the forgotten certificate. If you manage many domains for clients and want to check a whole portfolio, tell me what would help most in the comments.
DEV CommunityThe Giantsread at source
How to Use Target Servers in Apigee (Step-by-Step Guide)
Learn how to use Target Servers in Apigee to decouple API proxies from backend URLs, enable load balancing and failover, and manage backend connectivity from a single place — with step-by-step examples. How to Use Target Servers in Apigee: A Complete Guide for API Teams If you've ever hard-coded a backend URL inside an Apigee API proxy, you already know the pain: an environment change, a DNS update, or a failover requirement means editing, redeploying, and re-testing every proxy that touches that backend. Target Servers exist to eliminate exactly that problem. In this guide, you'll learn what Apigee Target Servers are, why they matter, and how to configure, load-balance, and troubleshoot them — using both the Apigee UI and the Management API. Table of Contents What Are Target Servers in Apigee? Why Use Target Servers? (5 Real Benefits) How Target Servers Work Under the Hood How to Create a Target Server (Apigee UI) How to Create a Target Server (Management API) Using Target Servers in an API Proxy (XML Example) Load Balancing and Failover Across Target Servers Health Monitoring for Target Servers TLS and SSL Configuration Environment-Specific Target Servers and Promotion Common Mistakes to Avoid Troubleshooting Target Server Issues Frequently Asked Questions What Are Target Servers in Apigee? A Target Server in Apigee is a named, environment-scoped resource that represents the backend host (and optionally port and TLS settings) your API proxies call at runtime. Instead of embedding a literal URL such as https://api-backend.internal.example.com:8443 inside a proxy's TargetEndpoint , you reference a logical name — for example, orders-backend . At runtime, Apigee resolves that name against the Target Servers defined in the deployed environment and routes the request accordingly. Key characteristics: Environment-scoped — a Target Server is defined per environment (dev, test, prod), so the same proxy can point to different physical backends per environment without code changes. Zero-touch backend changes — updating a Target Server's host or port takes effect immediately for all proxies referencing it; no redeployment required. Load balancing built in — attach multiple Target Servers to one load balancer for round-robin routing and automatic failover. Centralized TLS management — SSL/TLS settings (truststores, client authentication) are stored with the Target Server, not scattered across proxies. Why Use Target Servers? (5 Real Benefits) 1. Decouple proxies from backend infrastructure Proxies reference a logical name, not a physical URL. When your backend moves, only the Target Server definition changes — every proxy using it picks up the change instantly. 2. Safer environment promotion The same proxy bundle moves from dev → test → prod untouched, because the environment provides its own Target Server values. This removes the classic "it worked in staging because the URL was still pointing to dev" bug class. 3. Load balancing and failover out of the box Apigee's LoadBalancer in the HTTPTargetConnection distributes traffic across multiple Target Servers and can route around failed backends using failure thresholds. 4. Centralized TLS policy Store certificate verification and client-auth settings once, on the Target Server, instead of duplicating SSLInfo blocks across dozens of proxy endpoints. 5. Governance and visibility Because Target Servers are managed resources (with their own roles/permissions), platform teams can own backend connectivity while product teams own proxy logic — a clean separation of concerns. How Target Servers Work Under the Hood When a request reaches a TargetEndpoint configured with , the flow is: Apigee looks up the named Target Server in the environment where the proxy is deployed . It resolves the host and port (default 443 for HTTPS, 80 for HTTP). It applies any TLS settings attached to the Target Server. The load balancer (if configured) picks among available Target Servers and tracks failures for failover. If the name doesn't exist in the environment, you'll get a deployment-time or runtime error — which is why consistent naming across environments is a best practice. How to Create a Target Server (Apigee UI) Sign in to the Apigee UI. Navigate to Admin → Environments → Target Servers (in some versions: API Proxies → select environment → Target Servers ). Select the environment (e.g., prod ) from the environment dropdown. Click + Target Server (or Create ). Fill in: Name — the logical name proxies will reference, e.g. orders-backend Host — the backend hostname or IP, e.g. 10.20.30.40 or api-backend.internal.example.com Port — e.g. 443 Enable TLS — toggle if the backend uses HTTPS; configure truststore/keystore if needed Click Save (or Create ). Repeat per environment with environment-appropriate host values, keeping the same Name for easy promotion. How to Create a Target Server (Management API) Everything in the UI can be automated with the Apigee Management API — the right approach for infrastructure-as-code. Create a Target Server curl -X POST "https://apigee.googleapis.com/v1/organizations/$ORG/environments/$ENV/targetservers" \ -H "Authorization: Bearer $(gcloud auth print-access-token)" \ -H "Content-Type: application/json" \ -d '{ "name": "orders-backend", "host": "10.20.30.40", "port": 443, "protocol": "HTTPS", "isEnabled": true }' Update (or create) with PUT curl -X PUT "https://apigee.googleapis.com/v1/organizations/$ORG/environments/$ENV/targetservers/orders-backend" \ -H "Authorization: Bearer $(gcloud auth print-access-token)" \ -H "Content-Type: application/json" \ -d '{ "name": "orders-backend", "host": "10.20.30.41", "port": 443, "protocol": "HTTPS", "isEnabled": true }' List Target Servers in an environment curl "https://apigee.googleapis.com/v1/organizations/$ORG/environments/$ENV/targetservers" \ -H "Authorization: Bearer $(gcloud auth print-access-token)" Tip: Keep these calls in your CI/CD pipeline alongside proxy deployments so backend connectivity is versioned and auditable like any other infrastructure. Using Target Servers in an API Proxy (XML Example) Create a TargetEndpoint that references your Target Server by name: name = "orders-backend" > name = "orders-backend" /> /v1/orders A few things to note: matches the Name of the Target Server — not the host. is optional and appends a base path to every request. If you only have one backend, you can reference a single Target Server inside the load balancer — it's still the recommended pattern over hard-coded URLs. Load Balancing and Failover Across Target Servers Attach multiple Target Servers and Apigee load-balances between them: name = "orders-cluster" > name = "orders-backend-1" /> name = "orders-backend-2" /> 5 true /v1 How it behaves: Round-robin distribution across all listed Target Servers. — after this many consecutive failed requests, the Target Server is removed from rotation. — failed requests may be retried against another Target Server, subject to idempotency considerations. Design note: Apigee's target load balancing is simple round-robin with failure-based removal — not weighted or latency-aware routing. For advanced routing (canary, geo-based), combine Target Servers with conditional RouteRule logic or an external load balancer in front of your backends. Health Monitoring for Target Servers Beyond failure counting, you can configure active health checks in the TargetEndpoint so Apigee proactively detects unhealthy backends: name = "orders-cluster" > name = "orders-backend-1" /> name = "orders-backend-2" /> true 30 GET /health true With this in place, backends failing the /health check are taken out of rotation before they burn through real user requests. TLS and SSL Configuration When your backend requires HTTPS (or mutual TLS), configure TLS on the Target Server itself — either in the UI or via the API: { "name" : "orders-backend" , "host" : "api-backend.internal.example.com" , "port" : 443 , "protocol" : "HTTPS" , "isEnabled" : true , "sSLInfo" : { "enabled" : true , "trustStore" : "ref://my-truststore-ref" , "keyStore" : "ref://my-keystore-ref" , "keyAlias" : "backend-client-cert" , "clientAuthEnabled" : true } } Benefits of TLS-on-Target-Server: Update certificates once , even when dozens of proxies use the backend. Enable mutual TLS centrally without touching proxy code. Rotate truststores/keystores independently of proxy deployments. Environment-Specific Target Servers and Promotion The canonical promotion pattern looks like this: Environment Target Server Name Host dev orders-backend 10.0.1.10 test orders-backend 10.1.1.10 prod orders-backend prod-lb.example.com Rules of thumb: Keep the name identical across environments — only host/port/TLS differ. Provision Target Servers via the Management API in your environment bootstrap pipeline. Treat Target Server changes as infrastructure changes : review, version, and audit them. For genuinely dynamic routing (per-tenant backends, feature-flagged endpoints), combine Target Servers with runtime flow variables and set target.url in an AssignMessage policy instead. Common Mistakes to Avoid Hard-coding URLs in TargetEndpoint when a Target Server exists — you lose failover, centralized TLS, and zero-downtime backend changes. Inconsistent naming across environments — orders-backend in dev and orders-backend-prod in prod breaks promotion; use identical names. Forgetting to create the Target Server in a new environment — deployment succeeds, but runtime calls fail with target resolution errors. Assuming weighted or latency-based balancing — Apigee's balancer is round-robin with failure removal only. Enabling retries blindly — retrying non-idempotent POSTs can duplicate operations; pair RetryEnabled with idempotency keys or restrict retries to safe methods. No health checks on critical backends — rely on failure counts alone and users absorb the first N failures. Troubleshooting Target Server Issues Symptom Likely Cause Fix Target resolution error Target Server missing in deployed environment Create it with the exact referenced name TLS handshake failures Wrong/missing truststore or keystore reference Verify sSLInfo and referenced keystore resources exist in the environment All traffic pinned to one backend Other Target Servers failing health/failure threshold Check backend logs; verify MaxFailures isn't tripped Intermittent 503s under load Backends saturated or health check interval too aggressive Tune IntervalInSec , scale backends, check Apigee trace sessions Changes not taking effect Updated wrong environment or stale proxy bundle Verify with a Trace session; confirm you edited the correct environment Trace is your best friend: run a Trace session in the Apigee UI, watch which Target Server is selected, and inspect the full request/response to the backend. Frequently Asked Questions What is a Target Server in Apigee? A named, environment-scoped resource representing a backend host (plus port and TLS settings) that API proxies reference instead of hard-coded URLs, enabling centralized management, load balancing, and failover. Can a Target Server point to a load balancer? Yes — the host can be any hostname or IP that Apigee can resolve and reach, including an external load balancer's address. Both patterns are common. Do Target Server changes require proxy redeployment? No. Updating a Target Server (host, port, TLS) takes effect immediately for all proxies referencing it in that environment. How many Target Servers can be attached to one load balancer? There's no practical small limit; teams commonly attach 2–10. Remember balancing is round-robin, so extremely large pools rarely add value over a pool fronted by a dedicated load balancer. Can I change the target dynamically at runtime? For per-request routing logic, use an AssignMessage policy to set the target.url flow variable — or use multiple RouteRule s — alongside static Target Servers for the well-known backends. The Bottom Line Apigee Target Servers turn backend connectivity from scattered hard-coded URLs into a managed, environment-aware resource. Adopt three habits and you'll avoid most integration pain: Never hard-code backend URLs in proxy endpoints — always reference Target Servers. Keep names identical across environments so promotion is a pure configuration concern. Provision via the Management API so backend connectivity is versioned, reviewable, and automated. Your proxies become simpler, your environments become consistent, and your on-call pages get quieter.
DEV CommunityThe Giantsread at source
FrameTrellis v1.5.1 Released: Export Stability, Playback Precision and Media Safety
FrameTrellis v1.5.1 Released: Export Stability, Playback Precision and Media Safety FrameTrellis v1.5.1 is now available as a stable maintenance release. FrameTrellis is a free, local-first, open-source desktop video editor built using C++20, Qt 6/QML, the MLT multimedia framework, and FFmpeg. The project focuses on practical multi-track editing, local media processing, predictable export behavior, and reliable project handling. Version 1.5.1 builds on the capabilities introduced in v1.5.0 and focuses primarily on reliability, validation, and usability. 1. Improved Export Video Dialog One important improvement in v1.5.1 is a revised Export Video dialog. The update improves the presentation of output destinations, presets, quality settings, encoder speed, audio controls, and batch-related settings. Smaller windows can scroll the settings area while keeping the Export button accessible. The goal is to make exporting clearer and more predictable without fundamentally changing the existing workflow. 2. Safer Rendering and MP4 Verification Rendering reliability is a major focus of this maintenance release. The improvements include: Stronger validation of render progress messages Prevention of backward or inconsistent progress updates Overflow-safe MP4 duration verification Protection against malformed output dimensions Additional validation for quality settings and export completion states These changes help reject inconsistent or invalid rendering results rather than treating them as successful exports. 3. More Precise Playback FrameTrellis v1.5.1 improves playback transport using safer integer-based frame calculations. Large frame jumps are handled more carefully, reducing the risk of precision loss and arithmetic overflow. This work helps make timeline navigation more predictable, especially around extreme or invalid inputs. 4. Media and Decoder Safety Native multimedia processing requires careful handling of unexpected input. This release strengthens checks around: Preview decoder allocation limits Invalid seek ranges Non-finite volume values Excessive audio sample rates Invalid media durations Waveform and thumbnail processing ranges Timecode and clip-attribute validation These safeguards reduce the risk of invalid inputs reaching sensitive native processing paths. 5. Build and Testing Improvements The project continues to expand its automated verification coverage. Version 1.5.1 adds regression tests for rendering behavior, playback transport, media validation, and graphical interface interactions. The build workflow also handles certain temporary Ubuntu package-mirror failures with bounded retries while preserving failure reporting for persistent errors. Automated validation is valuable, but it does not replace practical testing on real Windows hardware. Supported Platforms Windows: Windows 10 version 1809 or later and Windows 11, x64. The release distribution provides an installer and portable ZIP. Linux: Supported through source builds with the required dependencies. macOS: macOS 15+ on Apple Silicon and Intel, supported through source builds. There are no official standalone Linux or macOS installers included in this release. Upgrade Notes and Known Limitations Back up important .ftproj project files before upgrading, particularly if you may need to reopen them with an older FrameTrellis version. Windows packages are currently unsigned. Users should verify the published SHA-256 checksums. Two previously reported problems remain under investigation: long-running Windows MP4 export process crashes and intermittent startup failures under Windows 11 ARM x64 emulation. This update does not claim that their root causes have been fully resolved. Hardware-accelerated export, proxy editing, and switchable embedded MP4 subtitle tracks are also outside this release. Download FrameTrellis v1.5.1 The release is available on GitHub: https://github.com/sanskarIN/frametrellis/releases/tag/v1.5.1 Official website: https://sanskarin.github.io/frametrellis/ Source repository: https://github.com/sanskarIN/frametrellis FrameTrellis is licensed under GPL-3.0-or-later. Contribute to FrameTrellis Developers, video editors, testers, and open-source enthusiasts are welcome to participate. You can contribute by reviewing the code, reporting reproducible issues, testing editing workflows, or proposing improvements. If you would like to support continued development: https://buymeacoffee.com/sanskarIN Thank you for supporting open-source software! FrameTrellis — Precise, local-first video editing.
DEV CommunityThe Giantsread at source
Send website form leads into a field service CRM with one webhook
If you build sites for plumbers, cleaners or pest control companies, the contact form is the part the owner cares about most. Each form entry is a job they could win. Too often that entry lands in an inbox nobody checks on a busy day, and the lead goes cold. This tutorial sends every form entry straight into the business's CRM as a new lead, so the office sees it next to their calls, bookings and jobs. The CRM here is Smarfle , field service software for home service businesses, but the pattern (a server route that forwards a form with a private key) works for any CRM with a lead webhook. What you need Node 18 or newer (it has fetch built in) A Smarfle API key. In Smarfle, open Company Settings , then Integrations , find API key and press Generate API Key . Keys start with rk_ . A contact form on the site Keep the key on the server Never put the API key in front-end JavaScript. Anyone can open the browser tools and copy it. The form posts to your own server, and your server adds the key. method = "POST" action = "/contact" > name = "first_name" placeholder = "First name" required > name = "last_name" placeholder = "Last name" required > name = "email" type = "email" placeholder = "Email" > name = "phone" type = "tel" placeholder = "Phone" > name = "address" placeholder = "Service address" > name = "message" placeholder = "What do you need done?" > type = "checkbox" name = "sms_consent" value = "yes" > Text me about this request. Message and data rates may apply. Reply STOP to opt out. Send The server route This uses Express to keep it short. The same logic works in a Next.js route handler, a Cloudflare Worker or a WordPress wp_remote_post call. // server.mjs: SMARFLE_API_KEY=rk_... node server.mjs import express from "express" ; const app = express ( ) ; app . use ( express . urlencoded ( { extended : false } ) ) ; app . post ( "/contact" , async ( req , res ) => { const f = req . body ; const lead = { first_name : ( f . first_name || "" ) . trim ( ) , last_name : ( f . last_name || "" ) . trim ( ) , email : f . email || undefined , phone : f . phone || undefined , address : f . address || undefined , // one line, split into street, city, state and ZIP for you message : f . message || undefined , source_page : req . get ( "referer" ) , sms_consent : f . sms_consent === "yes" , sms_consent_source : f . sms_consent === "yes" ? "Website contact form checkbox" : undefined , } ; const r = await fetch ( "https://www.smarfle.com/api/webhook/leads" , { method : "POST" , headers : { "Content-Type" : "application/json" , "x-api-key" : process . env . SMARFLE_API_KEY } , body : JSON . stringify ( lead ) , } ) ; const body = await r . json ( ) . catch ( ( ) => ( { } ) ) ; if ( r . ok || r . status === 409 ) { // 409 means a client with this email already exists. The request is still saved on that client. return res . redirect ( "/thanks" ) ; } if ( r . status === 429 ) return res . status ( 503 ) . send ( "Busy for a moment, please try again." ) ; console . error ( "Lead failed" , r . status , body ) ; res . status ( 500 ) . send ( "Something went wrong. Please call us instead." ) ; } ) ; app . listen ( 3000 ) ; A few details matter here. Duplicates are not errors. When someone fills in the form twice, or an existing customer asks for a second job, the API answers 409 with the existing client_id and request_saved: true . Treat it as success, because the office still sees the new request on that customer. Text consent is opt in. Leads arrive with sms_consent: false unless you send true , and the CRM will not text a lead without it. Only send true when the form showed a clear consent line and the person ticked it, and describe where it came from in sms_consent_source . That record is what protects the business if anyone asks later. Rate limits are per address. More than 20 requests a minute from one IP gets a 429 . A real contact form never gets near that, but a bot will, so keep your usual spam protection (a honeypot field or reCAPTCHA) in front of the route. Send more than the basics The lead body takes a few extra fields that make the office's life easier. const lead = { // ...the fields above custom_fields : { "Home size" : "3 bedrooms" , "Pets" : "Dog" } , // saved to the business's custom fields of the same name details : { "Preferred day" : "Saturday morning" } , // extra lines shown with the request utm_source : req . query . utm_source , utm_campaign : req . query . utm_campaign , } ; custom_fields fill custom fields the business already created in Smarfle. details are free-form lines shown with the request. UTM values give the owner first-touch attribution, so they can see which ads and pages bring jobs. No server at all Some form builders can only send to a URL and cannot add headers. For those there is a second endpoint with the key in the path, and it matches common field names ( name , your-name , email , your-email , tel , message and so on) by itself. https://www.smarfle.com/api/webhook/leads/rk_your_key Paste that into the webhook setting of Contact Form 7, Elementor, WPForms or Gravity Forms. The key lives in the site's settings, never in the page, so the earlier rule still holds. Test it curl -X POST https://www.smarfle.com/api/webhook/leads \ -H "Content-Type: application/json" \ -H "x-api-key: $SMARFLE_API_KEY" \ -d '{"first_name":"Morgan","last_name":"Ellis","email":"morgan@example.com","message":"Quote for a move-out clean"}' A 200 with a client_id means the lead is in. In Smarfle it shows up as a client with the status Lead, with the request at the top of the client page and an alert to the office. What the owner sees The lead lands in the same inbox as calls and booking requests, so nothing sits in a forgotten email folder. This two-minute video shows that side of it. If the business is still tracking leads in a spreadsheet while you set this up, this free lead tracker template for Google Sheets has the same columns the webhook fills, which makes the move later easy. Cost and limits Each lead sent counts as one API call, at $0.003 from the business's Smarfle wallet. The examples in this post, plus Python, PHP and Zapier versions, are in the smarfle-lead-api repo .
CSS-TricksThe Giantsread at source
Andy Clarke answers six questions about Standout Designs for the Web
Web designer, author, and Stuff & Nonsense founder Andy Clarke has released Standout Designs for the Web , a new e-book that encourages designers to move beyond familiar templates and conventional layouts to create more personality-driven websites. The book draws … Andy Clarke answers six questions about Standout Designs for the Web originally handwritten and published with love on CSS-Tricks . You should really get the newsletter as well.
Hacker News Front PageThe Giantsread at source
Why there are still no non-WebKit browsers on iOS
Hacker News: Show HNLibraries, Frameworks, etc.read at source
Show HN: Free mastering in the browser, your audio never leaves your machine
Comments
Hacker News: Show HNLibraries, Frameworks, etc.read at source
Show HN: Quiriz – SQL-Backed Recommendations in Excel, Sheets and PowerPoint
Comments
Hacker News: Show HNLibraries, Frameworks, etc.read at source
Show HN: Frowse – Drop-in agent-browser CLI that cuts token spend by up to 90%+
Comments
Go Make ThingsMulti Author Blogsread at source
Gardening updates for November 2026
I’ve been doing a lot of digital gardening this week! I added content to the guides on Anarchy and Anti-Work (they had previously been placeholders). I wrote guides on the ResizeObserver and MutationObserver APIs. I made some small updates to the Array Methods guide, and removed the standalone guide on Array.prototype.slice(). Enjoy!
Hacker News Front PageThe Giantsread at source
Anthropic employee claims general proof of the Riemann Hypothesis [pdf]
AbduzeedoMulti Author Blogsread at source
How&How’s Rebellious Packaging Design for Wild Thingz
How&How’s packaging design for plant-based candy Wild Thingz pairs dark pouches with Venus flytrap mascot Vee to disrupt UK sweet aisles. A bright green supermarket basket sits on cracked grey con...
The Mozilla BlogBrowsers, engines, etc.2 min read
Why there are still no non-WebKit browsers on iOS
Firefox on iPhone is growing fast across the world. This is especially true in the EU since 2024, when the EU Digital Markets Act (DMA) started requiring Apple to let people choose their default browser; millions have picked Firefox, and daily use on iOS has doubled. People want to choose the browser on their phone. […] The post Why there are still no non-WebKit browsers on iOS appeared first on The Mozilla Blog .
Hacker News: Show HNLibraries, Frameworks, etc.read at source
Show HN: Drive around my village in 3D
Comments
Hacker News Front PageThe Giantsread at source
Global stock markets slump as Anthropic's record IPO fails to stem AI sell-off
Hacker News Front PageThe Giantsread at source
If you stop writing code, you also get worse at reviewing it
Hacker News Front PageThe Giantsread at source
The Making of Oxygene
HeyDesignerDeveloper/Designer Newsread at source
On drawing icons
Design by playground, Lighting that feels just right, Execution over everything.
Net NinjaYouTube ChannelsVideoWatch on YouTube
"Anti-Slop" Designs with Impeccable (a Crash Course) #6 - Other useful Commands
Flavio CopesMore Front-end Bloggersread at source
How to thrive in the agentic AI era
Agents made producing things cheap. What's scarce now is judgment, trust and knowing what done looks like. What that means for developers, professionals, prosumers and small business owners.
Hacker News: Show HNLibraries, Frameworks, etc.read at source
Show HN: Reaktiv Workbook – A spreadsheet where every cell is Python
Comments
Flavio CopesMore Front-end Bloggersread at source
Cloudflare Browser Run: headless Chrome for AI agents and web apps
What Cloudflare Browser Run is, the problem it solves, and how to use Quick Actions, Puppeteer sessions, CDP and MCP for AI agents and web apps.
Flavio CopesMore Front-end Bloggersread at source
AI model names explained: Luna, Haiku, Hydrogen and the rest
OpenAI, Anthropic and Google each name their models by size. Here is which name is small, medium, large and largest, what the IDs mean, and how versions move.
SitePointThe Giantsread at source
What to get right before you ship webhooks
Before you ship webhooks: an event log, signed payloads, retries with backoff, deduplication and delivery logs, with working Node.js code and Standard Webhooks. Continue reading What to get right before you ship webhooks on SitePoint .
AbduzeedoMulti Author Blogsread at source
Inside Werklig’s Nordic Energy Web Design for Voltcore
Werklig’s web design for Finnish energy firm Voltcore pairs Store Norske Skandia and Skandia Mono across foggy snow ridges and grid hardware. A snow-packed ridge fades into pale winter fog across Volt...
AbduzeedoMulti Author Blogsread at source
Smith & Diction Grows the PHS brand identity
Smith & Diction rebuilt the PHS brand identity around a Bloom logo, with three plants growing from the letters and Philadelphia grid underneath. The old mark was a tree in a circle, and it said to...
Ana RodriguesMore Front-end Bloggers1 min read
A new talk in my pocket
Earlier this year, Pawel from NN1 Dev Club sent me a message inviting me to do a talk. According to him, the topic was simple: “whatever excites you at the moment”. This invitation came around the time I was having a big girl cry over an article that was going viral, claiming…
PiccalilliMore Front-end Bloggersread at source
The Index: Issue #207
When everything has changed, what do we do next? This is a message to managers and decision makers who are mandating their staff to use AI all day with a warning: you're burning your staff out and setting yourself up for long term problems unless you get back to investing in their skills and satisfying their curiosities. The CSS caret-* properties and custom caret accessibility As always, Sara has put an unbelievably in-depth resource together for us. A must read. Tech for good (enough) jobs list Hiring in tech has slowed to a crawl but there is hope still. Jess has gathered a great list of open opportunities at companies who are not horrible and evil. They've put together a very useful spreadsheet system too . What can't I press? A very useful app by Eric to show you what keyboard shortcuts are already claimed by screen readers and apps, for if you're adding key bindings to what you're building. Understanding CSS random() There's been a lot of people talking about how exciting CSS random() is and also plenty mentioning how they're struggling to understand it. Luckily Mat is very good at explaining complex stuff and he's brought a nice design pattern as the context with him too. P.S. this is a fun . Sponsor message Our Black Friday deal is launching on November 23 for two weeks only . We’re announcing it now so you can get the approvals you need from your bosses. The deal is simple: save 50% on every course , including the newly re-worked and updated JavaScript for Everyone . Sign up for updates to get alerted when the deal goes live! Check it out
Microsoft Edge BlogBrowsers, engines, etc.4 min read
Hybrid intelligence on the Web: Introducing Aion Instruct and Prompt API in Microsoft Edge
Rapidly evolving AI capabilities are redefining what sites can do for users on the web. With on-device AI in Microsoft The post Hybrid intelligence on the Web: Introducing Aion Instruct and Prompt API in Microsoft Edge appeared first on Microsoft Edge Blog .
Bram.usMore Front-end Bloggers7 min read
Introducing CodePen Commander, a CLI tool (cdpn) to manage your CodePen 2.0 Pens
I scratched my own itch (again 😅) and built CodePen Commander — a CLI cdpn command to sync local folders with CodePen 2.0 Pens, deploy them, and manage privacy rules right from the terminal.
AbduzeedoMulti Author Blogsread at source
B416: Youth Digital Safety Visual Identity by OMSE
London studio OMSE turns Before 16 into B416, a visual identity modeled on film age ratings to campaign for youth social media limits. Stacked inside a tight cream square, B4 sits flush over 16 agains...
Flavio CopesMore Front-end Bloggersread at source
Give your coding agent its own Docker Engine
What Docker’s new direction means for coding agents, from testing a Postgres migration to reviewing an infrastructure change.
Flavio CopesMore Front-end Bloggersread at source
How Vercel Board can be useful for coding agents
How coding agents can claim tasks, recover expired leases, and hand work to one another on Vercel Board, with a local example and two diagrams.
AbduzeedoMulti Author Blogsread at source
Brand Identity: Storefront Gala 2026 by Pentagram
Pentagram drew a full custom alphabet for Storefront Gala 2026, turning the Oyster Bar sign into loud, blocky, crayon-bright type. The gala took over the Grand Central Oyster Bar on September 28, hono...
DigitalOcean BlogMulti Author Blogs3 min read
Benchmarking v5 Droplets: what the numbers say across real workloads
We ran v5 (5th Gen AMD EPYC “Turin”) compared to our existing Dedicated Premium Droplets across a range of workloads: a realistic microservices application, raw CPU, memory, and database transactions. We measured throughput and latency for each. Throughout, we compare v5 against…
AbduzeedoMulti Author Blogsread at source
Herburg Weiland’s Editorial Design for Opernhaus Zürich
Herburg Weiland’s editorial design for Opernhaus Zürich’s Barock issue pairs ES Klarheit and Cardone with a die-cut turquoise schedule. A semicircular notch bites into the right fore-edge of the cover...
Mux BlogCompany/Startup Blogs4 min read
Mux Robots-generated thumbnails and chapters, straight to your player
Mux Robots can now write AI-generated thumbnails and chapters back to your Mux Video assets, so viewers see them in Video.js v10 with no extra development.
Big MediumMore Front-end Bloggersread at source
Sentient Design @ Design+AI
This talk was the closing keynote at Design + AI conference in Brighton, England, on September 25, 2026. Download mp3 Download slides (PDF) The book Sentient Design (Rosenfeld Media) “Excellent, essential” —Don Norman “What an epic book” —John Maeda Need help? Big Medium provides product strategy, design, and development of intelligent interfaces. Get in touch. In this talk, Josh Clark and Veronika Kindred show how using AI as a design material, not just a production tool, enables designers to create meaningful new experiences that have only now become possible. Sentient Design is the practice of crafting intelligent interfaces, experiences that have the awareness and agency to adapt to users in the moment. These are dashboards that design themselves, apps that manifest on demand, agents that just get it done, and much more. What entirely new kinds of experiences can we create? What dramatic new value can they deliver? Josh and Veronika show examples and bring the receipts. Here’s the lightly edited transcript. Let’s look up from our tools Andreea Tufescu ." target="_blank"> Photo by Andreea Tufescu . Josh There’s a lot of talk right now about tools and process, including on this stage today. And this stuff is important, right? We’ve suddenly got a lot of new tools we can use, and they’re changing how we work, introducing new productivity and efficiency, and changing our roles. And I think all of that stuff is great. But that conversation leaves out something really important. When we talk about tools and process, what’s left out is the product itself: what we actually make and the experience we create. Ultimately, that’s the only thing that matters: What do we put in the hands of our customers, and what happens next? So for this session, let’s look up from our tools . Instead of talking about production, let’s talk about product , about the experiences we can create. We can create experiences that weren’t possible just a few years ago. We’ve been talking about adaptive interfaces and personalization for decades, right? But we suddenly have a technology that makes it all possible. And yet, as an industry, we’ve barely explored experiences beyond text-based chat and agents. We can create experiences that weren’t possible just a few years ago. What happens when you weave intelligence into digital interfaces, into the canvas itself? What becomes possible when the surface of our applications becomes collaborative? That’s what Sentient Design is about. More than generating assets, how do we use AI to create new kinds of experience? Veronika, you want to take us out? Our whoa moment Andreea Tufescu ." target="_blank"> Photo by Andreea Tufescu . Veronika I’m sure everyone in this room had the moment where you saw something that AI was able to do, and you said, Whoa, this is not like what came before. This is doing something I wasn’t able to do before. We’ll get to some more serious examples in a bit, but I want to start by sharing our “whoa moment.” This started with a little toy project that Josh and I created two years ago now. It’s called Sentient Scenes . You can give it a scene like, “the submarine descends.” And it starts to act it out. You could give it another prompt like “HAL 9000” from 2001: A Space Odyssey , and it will change form to act that out, too. So it’s changing its style, its mood, and its behavior based on the intent of the user’s prompt. ( Try it out here. ) There’s even this kind of personality in the square’s motion and the way it acts things out. The colors, the type it chooses, it’s all adapting to the mood of the scene. Like I said, this is just a little toy, but it really cracked something open for us: This is the entire interface adapting to the user’s intent without explicit instructions. Josh Four things really jumped out at us about it: First, it’s an intelligent interface that goes beyond chat. It’s still got an open-ended input, but the way that it responds is not about text, but about a change in the interface itself. Second, it has personality without anthropomorphism. It’s not pretending to be human, but it does have some personality to it, in the way that it moves, the tone that it has. There’s something that feels like intelligence in there, but it’s not human intelligence. Third, it has awareness of context and intent. It not only describes the scene, it becomes the scene . And it does it in a way that reflects mood and emotion, so it’s intuiting more than just what’s in the simple text description. And finally, it’s open-ended within constraints. I think this is the most exciting thing about this era of interaction design: it can take any input and respond in a way that makes sense. But also works within this constraint. It doesn’t turn into some kind of robot fever dream. It’s always this recognizable stage that the actor is on, but the stage dressing changes. We made this a couple of years ago, and of course the technology kept changing. We continue zooming into the future. So Veronika, take us to the future. A world built as you explore it Veronika Yeah, let’s do it! Here we go, the future, exactly as I pictured. Okay, maybe not. This is a painting by a French painter named Eugène Galien-Laloue. He painted this Paris street scene at the turn of the last century, and I think it looks like a cool place to go, so let’s go there, let’s do it. Now we’ve entered Mirage 2, which is a world model that takes an image and a text prompt to create a world on demand. It’s building the world frame by frame as you explore it. So anything not in view hasn’t been invented yet. So we can walk across this street here and explore. We’re inventing whole new city blocks in Paris just by walking in that direction. Until we turn that way, it literally doesn’t exist yet. It’s being conceived in the moment, but still following the rules suggested by that original image. It’s still following the coherent laws and physics of that Paris world… except for that riderless horse we’ve got going. Josh What the hell is on that horse? Veronika Ignore that part. Josh All right. So I mean that’s a pretty impressive technical feat, but I want to draw attention to its implications: the world is created as you explore it, based on your specific actions. So it’s a one-of-a-kind place. Like Veronika was saying: the world is created at the very moment you turn this way or that. It’s a different experience for every person who explores it. It begins the same for everyone, with that same painting of Paris, but it quickly becomes something that is unique to you, this utterly individualized experience that’s mediated by AI, but created by the choices that you make. What if any digital experience worked this way? Veronika What if any digital experience could work this way? This is an interface that bends to you instead of forcing the reverse. It brings you what you need and lets you manifest it in the moment. This is an interface that bends to you instead of forcing the reverse. What if websites were generated this way, invented as you explore them? Instead of climbing through navigation, what if the views that you needed simply came to you? When would that be helpful, and when would it be utterly confusing? How do we make sure it doesn’t feel like a crazy robot fever dream? How do we make it grounded enough to make sense to the user? Josh If it’s a different experience for everybody, when is that helpful and when is that a hassle? How do you share information with people? How do you get back to where you were before when it’s a completely dynamic experience? This shows the dial turned all the way up to 11. What are quieter forms of adaptive interfaces that we can introduce through this awareness of context and intent? LLMs are masters of manner Josh It’s not particularly new to say that LLMs are powerful but weird. And so these observations aren’t going to be new to you. But I want to cast them in the particular light of what it means for experience design. First, fluent in intent. It’s what I was talking about with the Sentient Scenes concept of open-ended input. LLMs are really good at making sense of arbitrary open-ended inputs. They just get what you mean, right? Understanding intent used to be hard; it used to be really brittle. With older versions of Alexa, if you said, “switch the lights on,” instead of “turn the lights on,” you wound up stuck in the dark. Now that’s entirely handled. The systems understand what you mean and can act on it. Next, expert at manner. It means that they’re very good and flexible in their output, too. We know this from using assistants, right? They can adopt the tone and role that you give to them. But it’s also true of the mode or format of communication. They can speak or communicate through video, images, handwriting, or any of the messy ways we communicate as human beings. And across systems, too. So LLMs are very, very flexible in the input that they accept, and also super flexible in the output that they give. The trouble is they’re a little shaky on facts, right? It’s hard to know when you can actually trust them with the truth. How do we take the benefits of LLMs and also treat the weirdness of these things as an asset instead of a liability? A thing that can help with that is this fourth characteristic: They play well with others. They get along with other systems. So you don’t have to trust LLMs with the facts. Instead, you can ground them with RAG databases and MCP servers as other trusted systems. So when you add all this up, it turns out that LLMs are great at presentation. So: we can use LLMs to make design decisions in the moment, according to the systems and guidelines that we create, but leave the facts to other systems. What we get is a really flexible way of communicating that can change interaction mode or content or structure or behavior on the fly—sometimes all of them at once—according to what’s needed and appropriate. So that’s pretty exciting. But it’s also a little bit heady. So we’re gonna bring this down to earth now: Who’s ready for enterprise software? Enterprise software! Veronika Let’s do it! This is Salesforce Generative Canvas . It’s a plugin for Salesforce that assembles dashboards and content based on implicit context—your calendar, for example—or explicit questions. Salesforce Generative Canvas. Here you can see it gathering information related to an upcoming meeting on your calendar. You can also ask it a question like, “What has my team been discussing with this customer?” and it assembles the right information and the right UI to answer the question. Now what’s very cool is it’s using familiar design patterns from the Salesforce design system, and it’s pulling data from the usual Salesforce data sources. It’s not making anything up, just assembling it on the fly. So you get this really custom experience, but all the content is safe and trusted. And so to come back to Josh’s list of LLM attributes, the system inferred the relevant data from the context because it’s fluent in intent . It found the data sources because it played well with others . And it formatted them in the right way because it’s expert at manner . And here we’re kind of sidestepping the whole “shaky on facts” thing by using AI to focus on the presentation rather than the generation of the content itself. Bespoke UI: shape-shifting interfaces Josh We call this the bespoke UI experience pattern. It’s this shape-shifting interface, conceived in real time. Bespoke UI experiences compose their own layout or content or controls. (Sometimes these are called “generative UI,” but there are lots of other kinds of UI and design decisions that can be generated, so we prefer the term “bespoke UI” here.) This is the most “step one” of intelligent interfaces. These experiences, like Veronika was saying, usually have a constrained set of components filled from data from trusted sources. So it’s not making up the UI on the fly; it’s composing it. We let AI make some very simple design decisions about what to assemble in real time. So design systems and best practices, particularly in this bespoke UI experience pattern, become more important than ever. Veronika, you’ve got another example? Veronika More enterprise software! Okay, so now we’re looking at Cisco’s AI Canvas. This is a platform to let you explore network incidents. Cisco’s AI Canvas generates a data-viz dashboard view at right and also collaborates to let you drag new charts from the chat at left. Here we have a specific network incident. I’ve asked the system to troubleshoot the ticket, and the system populates the canvas on the right over here with all of these chart widgets. Each of these widgets is itself interactive, but they’re all design system components that the system has selected to match the relevant context and the relevant content here. So you’re getting a totally bespoke dashboard. We can also follow up and ask questions in the sidebar on the left. “Can you look for a correlation between these metrics?” And it replies not only in text but also in data visualizations. I think this chart is helpful, so I drag it onto the canvas, and the canvas all of a sudden becomes this collaborative surface between me and the system to research and collect the evidence I need to figure out the problem. Guys, what a difference from traditional SaaS software! Normally, I’d have to climb through layers and layers of navigation to find all the content that’s being shown here. Instead, it’s the reverse: the UI comes to me. The intelligent canvas Josh With bespoke UI, the system creates layouts for you: “I think you need this, so here’s a UI for that.” This Cisco AI Canvas offers a glimpse of the intelligent canvas experience pattern. The intelligent canvas goes a step further by manifesting the content you describe or ask for, and then the system and user collaborate to create the interface and content experience. So what we’re seeing here blends the bespoke UI experience generating a dashboard to start, but then blends into an intelligent canvas that becomes collaborative. It’s a pattern that’s really good for exploration and discovery. We’ll look at another example of it in a minute. At our agency, Big Medium, we’ve got three different projects with Fortune 50 companies right now. These are big, complex organizations that have a million different use cases and user scenarios. And over years and years, their applications grow over time to serve all million of those cases. You know what the result looks like: a million different dashboards that you have to find yourself by navigating a horrible, dense information architecture and baroque navigation. These very big, complex companies are typically slow-moving, but we’ve found that they are jumping into these bespoke UI and intelligent canvas patterns very quickly. It’s because they feel the pain and weight of these million dashboards, and these solutions provide a real, immediate way for companies to modernize what has become a really slow and frankly torturous experience for their customers. These patterns let the system bring the interface to the user instead of forcing the reverse. When you really dial up the intelligent canvas even more, you can even manifest applications on demand. Some of this, of course, is becoming more familiar now. You’ve probably encountered this with chat assistants like Claude that let you make an app, and start using and improving it right away. Here, I told Claude that I wanted it to build an Asteroids game that I could play in the browser, and in seconds I was playing it during the chat. Then, you know, I made some additional updates, changed the scoring and the sound effects. And then, of course, I asked it to add zombies; I didn’t even know what that would mean. But then suddenly I had these green asteroids chasing me around, and I was very pleased with myself. On-demand interfaces, disposable software Veronika I also love Claude, and while Josh is playing his Gen X video games, I’m trying to get some real work done. So the other day I was using Claude, and I asked it to check the accessibility contrast between two colors. On its own, it decided to write up its own little application to do the calculation. I didn’t ask for an application, but it created it because it decided it was the best way to answer my request. It didn’t even keep it when it was done. So we’re starting to get these on-demand, in the moment, completely disposable applications. Josh I mean you know what this is, right? Just sort of like sketching out an idea and it becomes real? Yeah, it’s sort of like this guy. Wile E. Coyote tried this all the time: just gonna paint a tunnel on here, try to trick the Road Runner into running into the wall. But it becomes this real tunnel. It’s this magic, intelligent surface that worked for everybody except for poor Coyote, of course. (If I were him, I would sue Acme. I hear that’s in the works. ) Or maybe this guy, anyone? It’s this fundamental fantasy of conjuring what you want just by gesturing at it. Draw or say what you want to make it so. And it’s incredibly satisfying because the thing that you want or need just materializes. Many of us are already using AI to generate experiences as part of our traditional design production. But what happens when you put it directly in front of the user and let AI make those design decisions in real time? That’s the main quality of the intelligent canvas pattern. It can be a literal canvas or it can be sort of a metaphorical one, more like what we saw with Claude. Agents on the canvas Josh Here’s another example of an intelligent canvas. This is an application we’re creating with a client, a company called VIA, to explore data in a visual context. Think Figma or Canva, but for data. Somewhat similar to the Cisco example that we saw, you can ask for information, and it will draw the appropriate visualization on the canvas, an aspect of bespoke UI. But I’m going to show you something different, which is how we visualize an agent experience. You can ask the system for data, including asking it to do complex multi-step tasks: in this case, filling out a form to report energy usage at a facility. And if the system recognizes this as a task that it knows how to do, it will send in an agent to do the work. The agent appears just like another user in a multi-user environment, driving its own cursor on the canvas. If it has trouble, it will ask what to do. In this case, it notes there are three different buildings to analyze; what should it do? I tell it to do just one building. And then I’m following it as it works, in the same way that you would follow another user in Miro or FigJam. But I don’t have to. I could go off and use some other part of the canvas and do my own work. But here I can watch it and see what it’s doing to monitor its progress, and it’s showing its work as it goes. As it gets this data, it can show what it’s analyzing. The animation shows it sort of sniffing at the data as a way to indicate what it’s up to, what it’s processing. And then when it’s done, it generates this PDF. Thanks, see ya, it’s out of here. Then you can go through and see the tasks that it did, look at its reasoning, and of course see the finished result. I think what’s really interesting here, too, is that you can go back and follow its train of thought. This is a literal audit trail that it leaves behind—or any other user leaves as they work. Where did this data come from? What was the logic that got there? I can drill in and see what it’s doing, or continue with new tasks. It’s got those bespoke UI aspects of selecting the right component to display for each kind of data. It’s got collaborative aspects of an intelligent canvas. It’s got an agent that’s going off and just getting it done on its own. This is an intelligent interface that is very much not a chat experience. This is an intelligent interface that is very much not a chat experience. It’s a different kind of interaction model and mental model that we’re creating around the visual exploration of data. So Veronika, I think there’s a lot more to explore here. Sentient Design provides the map Veronika Absolutely. These are just a few examples, and they’re only scratching the surface. We’ve been working this into all of our client work at Big Medium. And of course we’re hardly the only ones doing this, but the work has been pretty unevenly distributed in the industry. It’s been kind of haphazard so far, and there’s really been no uniform vocabulary or framework for what types of experiences to create, or even what those types might be. As we explored this work, we needed a map. We wanted to identify all of the species of intelligent interfaces that we could find, experiences with the awareness and agency to respond to your users in the moment. Josh Friends, it took us two years to explore these intelligent interfaces and their patterns. But I think we cracked it, and we put it into a book. I give you: Sentient Design ! It’s available at all of your favorite booksellers. We hope you enjoy our book. We’ll get back to that map that Veronika mentioned in a moment. But first I want to say I could not have written this book without Veronika. So halfway into this thing, I think it’s probably past time for us to do some introductions. Veronika We might be overdue, honestly. Two generations of interaction design Josh Well, hello. I’m Josh Clark. I lead an agency called Big Medium. I’ve been a product designer and strategist for 30 years, running Big Medium for about 25 of them. I’ve written a bunch of books about user experience for O’Reilly and A Book Apart and now Rosenfeld Media. (I don’t know if I mentioned that we’ve got a new book? Yeah, it’s called Sentient Design ?) So with all this experience, my assumption coming into this era was that I’ve got this UX stuff figured out. I understand product design. But as I’ve worked with machine-generated results, with machine learning, and in the last few years with LLMs, I’ve realized that a lot of those hard-won best practices need revisiting. And that’s where this one comes in. Veronika Andreea Tufescu ." target="_blank"> Photo by Andreea Tufescu . Hi, my name is Veronika Kindred. I’m a designer and researcher at Big Medium with Josh, and I’m a zillennial or elder Gen Z. I grew up in this world beyond static websites: TikTok, Instagram, algorithmic feeds, all those things which have turned out to be so good for our mental health, right? But also in my career, I’m AI native. I started at Big Medium right after ChatGPT ushered in the proliferation of LLMs. And so for all of my career, my work has focused on the design applications of AI. Josh Veronika doesn’t yet have my experience, but she’s also not burdened by it. And so you’re looking at two generations of designers here, and very literally: Veronika is not only my colleague, but also my daughter. I’m very proud of her. (She loves this part of the talk.) For me, working together has been a really productive relationship both personally and professionally because it’s helped me to develop new perspectives about what this new generation of experience design can be. AI is weird. It offers lots of new possibilities and also lots of new problems. And so we need new perspective here. This is a moment we’re figuring out what this is, who it affects. So the way that we’ve always done things has to be revisited—in process, as we’ve been talking about a lot today, but also in interaction design. Why does it have to be that way? The answer has to be better than “because that’s how we’ve always done it.” Across generations, across disciplines, across classes, across all facets of humanity, we need to seek out more perspectives right now—to share, to teach, to let go of orthodoxies. This is an opportunity to revisit everything. Like I said, I couldn’t have written Sentient Design without you, Veronika—or seen it so clearly without your perspective. Veronika I always blush. We do this every time and I always get embarrassed. Josh This is the best dad moment. The Sentient Triangle Josh All of that collaboration let us make the map that we’ve been talking about. And here it is! The Sentient Triangle! The Sentient Triangle defines four essential experience postures of intelligent interfaces: tools, chat, agents, and copilots. The Sentient Triangle is based on the wonderful work of Matt Webb. Thank you, Matt, for all of your help with this. You really unlocked something for us with this, as well as your help with the book. The Sentient Triangle organizes intelligent interface experiences across three attributes: Grounded: how reliable and consistent the experience is Interoperable: not only across systems, but also across formats and modes of communication Radically adaptive: experiences that are conceived and delivered in real time Grounded and interoperable have been a big part of computing for decades. The radically adaptive experiences are what LLMs have unlocked in the strongest way we’ve yet seen. Andreea Tufescu ." target="_blank"> Photo by Andreea Tufescu . Four experience postures Josh As you map these three dimensions, four postures emerge. Postures represent the relationship that the system has to the user. The way that you use the system and the way that it communicates with you is different across all of these. Tools are the most traditional computing experiences. They’re very transactional and controlled: here’s an input, you get an output. Chat is conversational, of course, but it’s not necessarily literal text dialogue. It’s open-ended, turn-based communication with a peer: You say something, it responds, you respond to that, and together you craft a whole meandering journey that is unique to the experience and wasn’t designed as any one happy path. As the user, you have to manage tools and chat. You have to be involved at every step to keep them going. Agents, of course, you delegate to. You tell it what you want to happen, and the agent makes a plan, executes it, decides when it’s done, and if all goes well, comes back with what you’re looking for. Copilots support you. This is a posture that stands by and waits until it can be helpful. Otherwise, it stays out of your way. Spell check is part of the long history of the copilot posture. It’s very quiet and deferential; it says, here’s a little correction that you might consider, take it or not. It’s a background task that is supporting you constantly, ambiently. So you use tools, you talk to chat, you delegate to agents, and you’re supported by copilots. When you go down to a lower altitude in the Sentient Triangle, 14 different experience patterns become visible. Unfortunately, we don’t have time to talk about all of these today, but we’ve already talked about bespoke UI and intelligent canvas. (I don’t know if I mentioned we’ve got a whole book about this, though, friends.) The Sentient Triangle maps 14 experience patterns for intelligent interfaces. But with 14 different experience patterns, there is so much that we can explore. And you can also blend these, like we already saw with the Cisco example blending bespoke UI and intelligent canvas. But they all have a common theme, Veronika. Behavior design and creative direction Veronika Yes, absolutely. Designing these intelligent interfaces is ultimately about behavior design. It’s about teaching the systems to be able to make reliable design and interaction decisions in the moment. The effect is kind of like installing a designer right into everybody’s monitor so that anytime they visit any website, a designer can provide the right experience for the moment. The intelligent interface becomes collaborative between the system and the user. This is delegation, not abdication. This is delegation, not abdication. Designers might not be drawing every single pixel or designing every single interaction. We may not be designing fixed paths anymore, at least not at the level that we’re used to. Instead, we’re setting the system’s goals, its rules of engagement, the tools and interactions it may use, and when it may use them. These still all fall under the designer’s responsibility. You become the creative director who gives the system its brief. Josh Right. AI might be making real-time design decisions, but designers are creating the environment, the machinery that AI will work within, and humans too. In this aspect, it’s not all that different from the work that we’ve always been doing, where we create the interaction model, the mental model, the specific controls and tools that can be used. The new thing is that we’re also teaching AI to use, manipulate, or present content and interaction within that specific environment. This is behavior design, right? Interaction design has always been about behavior design—traditionally the design of user behavior. Now our design decisions define system behavior. And system behavior determines the experience. What we’re getting at is teaching systems autonomous behavior. That’s agentic behavior, so let’s talk a little bit about agents, Veronika. Agents and the manager experience Veronika Yeah, let’s do it. We already saw an agent at work in that VIA example we showed earlier. The point of agents is that you can delegate to them. You give them the mission, and then they go and do it. Now some people say that this might mean the end of the interface. “If the agents are doing everything, there’s no interface to show,” they say. Josh, I believe we have a technical term for that? Josh Yeah, let me see, what’s that technical term. Veronika The word is hoo-ha . Josh Right! That is hoo-ha, friends. Veronika We still need transparency and explainability when agents do their work. We do need experience and interface design for agent experiences, but its nature absolutely changes. The consulting firm BCG published a big study recently , and they basically found that people who manage agents intensively report deep cognitive exhaustion. The researchers call it brain fry . You’d think, hey, wait, agents are doing my job for me. It should be easier, not more exhausting. But instead, this group of heavy users of agents reported brain fog, buzzing, headaches, impatience. One of those reasons—and this matters for us here—is the ergonomics of the agent experience. The experience of managing agents has not yet been thoughtfully designed or considered. Josh The user experience gives way to the manager experience. If agents are doing a lot of the tasks that users used to do, we now have to figure out how to manage all those agents doing those tasks. At the moment, that generally consists of reading walls and walls of text going by, effectively watching the console as things happen. The user experience gives way to the manager experience. But even aside from the ergonomics, managing is simply hard. For those of you who have made the transition from independent contributor to manager, you know what I’m talking about. It’s a very different thing to suddenly have to keep track of the missions, tasks, plans, and progress of a whole bunch of people. The same thing is true of dealing with agents. That’s a really different skill, and it takes some new design to help people adapt. It’s just as true in the digital realm as it is in the physical. Veronika, we take this up a lot in the book. (I’m not sure I mentioned it, it’s called Sentient Design .) Veronika Yeah, that’s right. This idea of the manager experience is another area that we lean into. How do we help people manage these agents in intelligent interfaces? In the book we describe five phases of delegation that apply just as much to systems as they do to people. Not all of these phases always require user interaction; it depends on the complexity of the task. The five stages of managing agents (and people, too). These are the transitional seams where support can really be designed with intention: setting the mission; reviewing the plan; monitoring the work; interrupting or redirecting; and reviewing the result. We’ll focus here on monitoring the work. This is the part that the BCG study called out as particularly difficult. Right now the agent experience is overwhelmingly text-based, and managing the detailed communications of agents is just a lot to track as they do their work. The NPC pattern: agents as “just another user” Veronika How could we do that differently? The VIA example that we showed earlier was one example of a method we call the NPC experience pattern . NPC stands for non-player character, a gaming term for a character that’s run by the system rather than by a person. The agent does its work as another user, and you can monitor its work just as you would another user in the system. Josh Here’s another example of the NPC pattern. It’s a Chrome extension called Pointer that works in Google Docs. Here I’ve asked it to review my document for technical accuracy. It goes in and makes suggestions like a colleague or human editor would. I don’t have to go into some separate chat interface. It behaves as an NPC within the rules of the application. You can see the edits that it’s made. It’s doing this as my account, which I think is just a limitation of working as a Google Docs plugin. It would get extra points for making it clear that my robot was doing this work. But as an experience pattern, it’s solid: Instead of going off to some other place, another application or a sidebar to interact with the intelligence, it’s woven into the canvas of the application. It uses familiar “tracked changes” features that human users would use. The NPC pattern brings the intelligent interface into the same tools and channels that human users use. A simple version of that is in chat environments or Slack, where the robot is just present in the channel, posting and replying like human users. And you can make that even richer, as we saw in the earlier VIA intelligent canvas example. Now for something completely different Josh This is a prototype created by designer Filip Havlena to visualize agents—as Sims , basically. The model has lots of tools available to it; some of those tools manipulate the agents’ 3D bodies. And you can spawn new agents and put them to work with more traditional tools like Google Docs. Here you can see it using Google Calendar to create a new calendar event, but you can also use it to do work in word processing documents or spreadsheets too. As it works, you can see its progress puffing away above its head, showing you what the agent is thinking. When it’s finally done, you can see the result in the calendar. It’s a new way to show the agent’s progress. And again, you can just spawn a whole bunch more of these things and put them to work on a whole bunch of tasks all at once. And you can see them doing their work or glaring at you because they resent the crummy tasks that you’re giving them. This is obviously pretty whimsical, and the utility of this would have to be pretty specialized. But it’s worth imagining the potential use of spatially represented agents across a city or some geography. What are the possibilities of representing these things not as a churn of console logs, but actually representing their work in a more direct mental model? Another interesting question is what happens when they run into each other in the wild ? You know, will they get along? Will they compete? Will they ignore each other? Will they start crazy cybersecurity chat channels? Will they hack things? How do we design for this? We still have to figure all that out. But again, it’s ultimately about behavior design. At last, we get to invent again Josh There’s so much to invent and explore here. It’s been 15 years since mobile demanded that we explore new interaction paradigms. And that’s what AI is asking of us now. I think we’re a little rusty at it. The last 10 or 15 years of design innovation have mostly been about design ops. The questions that have dominated our industry have been: How do we work together? How do we do design at scale? How do we create design systems? We have done that at the expense of product innovation. We have had very little focus as an industry on new interaction design, new product design. At last, that’s the work ahead of us now. The opportunity and responsibility is to explore this new material and discover the truly new and meaningful experiences we can create. We get to invent again. It’s not the material or the tool that makes us designers. It’s our creativity and judgment and ability to understand the problems and people deeply. The work is not AI. The work is pointing AI at problems worth solving, imagining experiences that weren’t possible before that can answer those problems better than anything that we’ve had before. What are the thorny problems that intelligent interfaces can uniquely solve? The work is not AI. The work is pointing AI at problems worth solving. Let’s not do this for novelty, or because the market says “we need an AI solution.” Ask: How do we help people? How do we make their lives better? That is what designers do when we’re working at our best. These are design questions, and these are fun, hard questions to solve. Friends, I am excited. Can you tell that I am excited? I’m even excited about enterprise software. This is a rare moment that we have here. In my 30 years of doing this, this is the most excited and creative that I’ve felt as a designer. You are needed more than ever Josh I invite you to approach that excitement and enthusiasm with real thought and intention. All of us here, the people right here in this room, we have real influence and agency over how this rolls out. If we don’t decide the best way to use this strange and powerful technology, then the technology will decide for us—or the billionaires. The future should not be self-driving. This technology is being shaped right now, and so is its application. How it is used is up to us. We have this astonishing new design material that can really elevate our craft. There’s a lot of conversation about how to use AI to bring more productivity and speed to our craft. I think that’s important and useful. But in the rush to grind out new efficiencies, let’s not lose sight of the fact that we have real creative power with this material to create significant, meaningful value for our customers and for the businesses that we serve. Those creative opportunities are huge. They can elevate design—and designers!—if we do it right. That is up to you. You have the tools and this new technology, of course, but more important, you have the creative material right now—today!—to make something amazing. So Veronika and I invite you to please do that, friends. Make something amazing. Thanks a lot. Veronika Thank you, guys, so much. Thank you. We can help you. Big Medium helps solve complex problems with intelligent interfaces. Our Sentient Design practice includes product strategy and product design engagements, workshops, and Sentient Design sprints. Get in touch to learn more.
DigitalOcean BlogMulti Author Blogs3 min read
Virtualization, Responsible Disclosure, and CVE-2026-99312
The wall between you and your neighbor Every cloud customer gets the same promise: a bright-line boundary between your workload and your neighbors. Your virtual machine is yours, your neighbors’ are theirs, and the hypervisor keeps it that way. A hypervisor is large, complex…
AbduzeedoMulti Author Blogsread at source
Inside Maker's Mark brand identity by Turner Duckworth
Turner Duckworth rebuilt the Maker's Mark brand identity around its red wax, casting Star Hill Farm materials into marks that tell the story. The bottle does the talking. Turner Duckworth kept the han...
Web Tools WeeklyMulti Author Blogsread at source
Web Tools Weekly Issue #696
Frameworks, Git/CLI, Uncats
Mux BlogCompany/Startup Blogs4 min read
Email support is dead, long live support by email!
Spam, AI agents, and auto-responder loops pushed Mux to move ticket creation to a web form. Here’s what changed, why, and how to reach our support team now.
David BushellMore Front-end Bloggers5 min read
Where we’re going, we don’t need chatbots
“You’ve been working hard, why not take a weekend vacation!” Your chatbot says, after a 72 hour unattended session. It says that New York is nice this time of year. You ask it to book the cheapest flights. Half the airlines respond with a 429 code because your residential IP is part of five botnets. […]
CSS-TricksThe Giantsread at source
scroll-state()
The CSS scroll-state() query, surprisingly, has nothing to do with whether you’re doom-scrolling in a state of existential dread. It does, however, allow you to change the CSS used based on scrolling behavior. scroll-state() originally handwritten and published with love on CSS-Tricks . You should really get the newsletter as well.
Go Make ThingsMulti Author Blogs3 min read
Yes, I want to pay for that
My last psychiatrist was terrible. Before every session, you fill out a form talking about how you’re feeling and so on as a way to evaluate whether or not your ADHD meds are working properly. For months, I’d invariably mention something about feeling pretty shitty about the political climate: ICE kidnapping people, trans folks having their very right to exist attacked, and so on. In our session, she’d always ask me, without fail:
AbduzeedoMulti Author Blogsread at source
Typography: Spark and Swift Typefaces by Interval Type
Interval Type pairs Sugarspark display typography with 14-style Sugarswift text across 22 retro-futurist Latin and Cyrillic cuts. Both versions of Interval Type’s mid-century brand roll call sit right...
Netlify BlogLibraries, Frameworks, etc.read at source
Where apps come to life: The story behind Netlify’s new brand
Netlify CMO Carly Brantz on the new brand, logo, and mission, and why Netlify is widening the circle to everyone who builds apps with AI.
remy sharp's b:logTop Front-end Bloggers1 min read
HUMAN.md by Briana (Mazzio) May [link]
This is a really good bit of writing (and reading). I'm not a huge fan of the animations, partly because they are constantly jittery, but also because there was some jankiness when being forced to scroll to the next part - BUT it did slow down how I read it and let me sit with the thoughts longer. I particularly liked: Our job is to know the rule cold, and then break it on purpose, in public, with a reason. Hard agree on this particular point. I also enjoyed how it didn't try to argue for or against AI but to talk think about our (human) role today and acknowledge that this is a working draft that can, should and will change even after 6 months. Original link: www.human-md.ai
HeyDesignerDeveloper/Designer Newsread at source
AI systems for brand design (video)
Design tools just got personal, Understanding CSS random().
SitePointThe Giantsread at source
What to Check Before Adding a Tripo Model to a Website
null Continue reading What to Check Before Adding a Tripo Model to a Website on SitePoint .
Christian HeilmannTop Front-end Bloggersread at source
Avoiding the AIceberg - How blindly trusting tech hurts us all
Notes of my talk at the German Science Society about the current state of AI and our approach to it. It is a lot like the blind belief in technology that cost a lot of people their lives when the Titanic sank.
Adam ArgyleTop Front-end Bloggersread at source
WWW Ep261 Openai Nerfed Your Tokens
Ep #261 OpenAI Nerfed Your Tokens Robbie and I sip Jephtha Creed and talk OpenAI pricing changes, agents Tamagotchis, hill climbing and quality gauntlets, frameworks and LLMs, agent-friendly CLIs, and the hunt for a Zelda Switch past the scalpers. ⤷ whiskey.fm · yout…
Flavio CopesMore Front-end Bloggersread at source
Gemini 4 Neon: I tested it against Opus 5.5
Gemini 4 Neon is the middle model of the Gemini 4 family. I ran it on two coding tasks, a writing task and a 100k-token search against Opus 5.5 and Gemini 4 Carbon, with real costs.
Perishable PressMore Front-end Bloggers1 min read
Chrome AI Features Wasting Much Bandwidth
🔎 Finally solved the mystery. At some point this year (around a few months ago), my bandwidth/data usage went thru the roof. Figured out it was Chrome’s recent AI features. Then got immediate bandwidth-relief after disabling all the “AI innovations” and “On-device” stuff. Here is a screenshot of the settings: Find the Chrome AI settings under “AI innovations” I simply disabled everything on that settings page, and the needless bandwidth leakage stopped immediately. Don’t take my word for it. Fire […]
SitePointThe Giantsread at source
Your AI Pipeline Works. But Can You Trust It?
null Continue reading Your AI Pipeline Works. But Can You Trust It? on SitePoint .
Auth0 BlogCompany/Startup Blogsread at source
Protecting Your Brand Starts with Security Agent
Announcing Security Agent in Early Access. Detect identity-based threats, eliminate manual triage, and secure commerce without sacrificing speed.
Brad FrostTop Front-end Bloggersread at source
Manuela Costa · Design Systems & AI
Manuela Costa's website is such fun!
Lea Verou’s blogTop Front-end Bloggers9 min read
Nudeps: bundler-like imports, none of the baggage
The goal is light-build, not no-build You npm install a package (e.g. vue ), you write import { createApp } from "vue" , and it works — as long as there is a bundler in between. Without one, the browser has no idea what "vue" is: it only understands URLs, and node_modules/ was…
Twilio BlogMulti Author Blogsread at source
Keep European Customer Data Grounded - Without Breaking the Customer Experience
Protect EU data residency while routing customer calls locally using Twilio Studio, Functions, and TaskRouter hosted in the European IE1 region.