<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Leo</title>
    <description>The latest articles on DEV Community by Leo (@leobaniak).</description>
    <link>https://dev.to/leobaniak</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F3997121%2F061e76e1-0a08-4d9d-827c-24f1e8b9e15b.png</url>
      <title>DEV Community: Leo</title>
      <link>https://dev.to/leobaniak</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/leobaniak"/>
    <language>en</language>
    <item>
      <title>Safari on HomeView is a short, square screen, and your sticky header will notice</title>
      <dc:creator>Leo</dc:creator>
      <pubDate>Sat, 14 Nov 2026 16:07:22 +0000</pubDate>
      <link>https://dev.to/leobaniak/safari-on-homeview-is-a-short-square-screen-and-your-sticky-header-will-notice-5ekk</link>
      <guid>https://dev.to/leobaniak/safari-on-homeview-is-a-short-square-screen-and-your-sticky-header-will-notice-5ekk</guid>
      <description>&lt;p&gt;Your header is &lt;code&gt;position: sticky&lt;/code&gt;. Your cookie bar is &lt;code&gt;position: fixed&lt;/code&gt; at the bottom. Your newsletter modal is tall, and its close button sits at the top. On a laptop, fine. On a viewport shorter than 600px, the header and the bar eat most of the screen and the modal runs off the bottom with no way out.&lt;/p&gt;

&lt;p&gt;That screen is now a Safari target. In a post on the WebKit blog, Jen Simmons announces that Safari runs on Apple HomeView, alongside Safari on macOS, iOS, iPadOS and visionOS. HomeView has a square, 7-inch display. People talk to it from across the room, or tap it up close.&lt;/p&gt;

&lt;p&gt;Her headline advice to developers is reassuring. Most likely, you don't need to do anything. I agree, with one condition. That only holds if you never baked a device shape into your CSS.&lt;/p&gt;

&lt;h2&gt;
  
  
  The assumptions that break
&lt;/h2&gt;

&lt;p&gt;The post names them directly. Some sites assume a screen is landscape or portrait, never square. Some assume the viewport is always taller than 600px. On HomeView it's shorter.&lt;/p&gt;

&lt;p&gt;That second one is the trap. Most of us never wrote it down. It piled up: a sticky header here, a fixed bottom bar there, a dialog sized against the design file.&lt;/p&gt;

&lt;p&gt;The post lists two ways it fails. Sticky or fixed-position headers and footers can leave almost no room for the main content on a short screen. And modals taller than the viewport, newsletter signups being the classic case, can leave users with no way to dismiss them.&lt;/p&gt;

&lt;h2&gt;
  
  
  Two declarations for the worst one
&lt;/h2&gt;

&lt;p&gt;Here's the quick fix the post gives for those modals:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight css"&gt;&lt;code&gt;&lt;span class="nc"&gt;.modal&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nl"&gt;max-height&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;90svh&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
  &lt;span class="nl"&gt;overflow-y&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;auto&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Read it mechanically. &lt;code&gt;svh&lt;/code&gt; is the small viewport height unit, measured as if the browser's toolbars are showing, so it's the conservative height. &lt;code&gt;max-height&lt;/code&gt; caps the box at 90% of it. &lt;code&gt;overflow-y: auto&lt;/code&gt; turns the modal into its own scroll container once the content is taller than the box. The box never pushes past the bottom edge, and the close button stays on screen.&lt;/p&gt;

&lt;p&gt;My take: this belongs in your base modal styles today, HomeView or not. A phone in landscape has the same short height. Which is exactly how the post suggests you test.&lt;/p&gt;

&lt;p&gt;The sticky header gets no snippet in the post, and I'm not going to make one up. It's a judgment call anyway. Decide what earns permanent space on a short screen. Usually less than you think.&lt;/p&gt;

&lt;h2&gt;
  
  
  Voice users call controls by name
&lt;/h2&gt;

&lt;p&gt;This part isn't about layout, and it's the part I'd take most seriously. Voice is a main way people use HomeView. Simmons puts it simply: someone speaking to a page isn't pointing at a button, they're calling its name. That works with semantic HTML. Real buttons, links and form fields, and a clear label on every control.&lt;/p&gt;

&lt;p&gt;The &lt;code&gt;div&lt;/code&gt; with a click handler and an unlabelled icon inside was already a problem for keyboard users. Now it's also a control nobody can ask for out loud.&lt;/p&gt;

&lt;p&gt;Media gets the same treatment. HomeView plays audio and video, and the post asks for captions as WebVTT files inside &lt;code&gt;track&lt;/code&gt; elements:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight html"&gt;&lt;code&gt;&lt;span class="nt"&gt;&amp;lt;video&lt;/span&gt; &lt;span class="na"&gt;controls&lt;/span&gt;&lt;span class="nt"&gt;&amp;gt;&lt;/span&gt;
  &lt;span class="nt"&gt;&amp;lt;source&lt;/span&gt; &lt;span class="na"&gt;src&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"theshow.mp4"&lt;/span&gt; &lt;span class="na"&gt;type&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"video/mp4"&lt;/span&gt;&lt;span class="nt"&gt;&amp;gt;&lt;/span&gt;
  &lt;span class="nt"&gt;&amp;lt;source&lt;/span&gt; &lt;span class="na"&gt;src&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"theshow.webm"&lt;/span&gt; &lt;span class="na"&gt;type&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"video/webm"&lt;/span&gt;&lt;span class="nt"&gt;&amp;gt;&lt;/span&gt;
  &lt;span class="nt"&gt;&amp;lt;track&lt;/span&gt; &lt;span class="na"&gt;default&lt;/span&gt;
    &lt;span class="na"&gt;kind&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"captions"&lt;/span&gt;
    &lt;span class="na"&gt;srclang&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"en"&lt;/span&gt;
    &lt;span class="na"&gt;label&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"English"&lt;/span&gt;
    &lt;span class="na"&gt;src&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"captions.vtt"&lt;/span&gt;&lt;span class="nt"&gt;&amp;gt;&lt;/span&gt;
&lt;span class="nt"&gt;&amp;lt;/video&amp;gt;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Run a recipe site? Safari's cooking experience builds a step-by-step view from schema.org &lt;code&gt;Recipe&lt;/code&gt; data in JSON-LD. If your recipes don't carry that markup yet, now there's a concrete reason to add it.&lt;/p&gt;

&lt;h2&gt;
  
  
  Stop reading the user agent
&lt;/h2&gt;

&lt;p&gt;Safari on HomeView reports an iOS user agent. Any script that maps an iOS user agent to an iPhone is now wrong about a screen on a kitchen counter. WebKit's advice is to drop UA sniffing and use feature detection, testing directly for the API you need. For the custom banner nudging people to install your app, the post points to Smart App Banners instead, so Safari decides whether a banner makes sense on the device at all.&lt;/p&gt;

&lt;p&gt;Same lesson every new form factor teaches. The device you sniffed for is never the only one sending that string.&lt;/p&gt;

&lt;h2&gt;
  
  
  Test on what you already own
&lt;/h2&gt;

&lt;p&gt;No HomeView on your desk? The post gives two options. Turn a phone to landscape and fix whatever breaks because of the short height. Or open Responsive Design Mode in Safari and set the viewport to 448×364.&lt;/p&gt;

&lt;p&gt;My verdict: this launch is less about one device than about one number. If 600px of height is holding something up in your stylesheet, find it. Start with the modal. Two declarations. Then scroll your site at 364px tall and count how much of the screen your header and footer keep for themselves.&lt;/p&gt;

</description>
      <category>safari</category>
      <category>webkit</category>
      <category>responsivedesign</category>
      <category>semantichtml</category>
    </item>
    <item>
      <title>Meta pulled app deploys out of Terraform and onto Argo CD and Kargo, cutting four-hour releases to minutes</title>
      <dc:creator>Leo</dc:creator>
      <pubDate>Sat, 14 Nov 2026 10:23:54 +0000</pubDate>
      <link>https://dev.to/leobaniak/meta-pulled-app-deploys-out-of-terraform-and-onto-argo-cd-and-kargo-cutting-four-hour-releases-to-2db0</link>
      <guid>https://dev.to/leobaniak/meta-pulled-app-deploys-out-of-terraform-and-onto-argo-cd-and-kargo-cutting-four-hour-releases-to-2db0</guid>
      <description>&lt;p&gt;Meta's Cloud Foundation team has taken Kubernetes application rollouts out of its Terraform release process, and routine application deployments that took more than four hours now take minutes, according to the CNCF. The foundation named the team winner of its End User Case Study Contest at KubeCon + CloudNativeCon North America 2026 in Salt Lake City. The new platform runs on Argo CD and Kargo across approximately 100 Kubernetes clusters that support AI research and inference.&lt;/p&gt;

&lt;p&gt;Behind the speedup is a structural change other platform teams can copy. Meta stopped shipping applications and infrastructure through the same pipeline.&lt;/p&gt;

&lt;h2&gt;
  
  
  One pipeline, two jobs
&lt;/h2&gt;

&lt;p&gt;The team has more than 15 engineers and runs those clusters across multiple cloud providers and accelerator families, per the announcement. Before the change, Terraform handled both infrastructure provisioning and Kubernetes application deployment. The full case study is titled "GitOps at Meta: How We Went From Terraform on Cron to GitOps for AI Infra", which tells you how the old loop ran.&lt;/p&gt;

&lt;p&gt;The CNCF lists three consequences of that design. Even a routine application update was tied to a lengthy infrastructure release. A stalled rollout could delay unrelated releases, because everything shared one deployment path. And there were no automated health checks to verify application status after a deploy.&lt;/p&gt;

&lt;p&gt;The second one is the on-call problem. A shared path means one stuck change holds the queue for every team behind it. A missing health check means the pipeline reports success on a deploy nobody has verified.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where each tool sits now
&lt;/h2&gt;

&lt;p&gt;The new split, as the CNCF describes it:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Terraform still manages infrastructure.&lt;/li&gt;
&lt;li&gt;Argo CD reconciles application deployments against configuration stored in Git.&lt;/li&gt;
&lt;li&gt;Kargo orchestrates release promotion across environments.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Some background for readers who haven't run either tool. Argo CD is a pull-based reconciler. A controller compares what Git says a cluster should be running with what it is actually running, and syncs the difference. Kargo works one layer up. It tracks versioned bundles of artifacts and moves them from one environment stage to the next, writing the change to Git so Argo CD can apply it.&lt;/p&gt;

&lt;p&gt;Per the announcement, this setup gives Meta independent rollouts, automated health checks and versioned release records. The CNCF says those records improve deployment traceability and recovery. For an SRE, recovery is the word that matters. A versioned record of what was promoted where is the starting point for a rollback that doesn't depend on someone's shell history.&lt;/p&gt;

&lt;p&gt;Meta also hid most of the machinery from application teams. Developers write a short application definition, and the platform generates the Argo CD and Kargo configuration from it. Application teams get independent promotion and health verification without maintaining that configuration themselves.&lt;/p&gt;

&lt;h2&gt;
  
  
  What the announcement doesn't tell you
&lt;/h2&gt;

&lt;p&gt;The press release has no detail on how the health checks are defined, what a failed check does to a promotion, or how rollbacks work in practice. It doesn't say how many applications have moved over either. "More than four hours to minutes" is Meta's number for routine deployments, and there is no breakdown behind it. The full case study may answer some of this. The announcement does not.&lt;/p&gt;

&lt;p&gt;The roadmap hints at where it still hurts. Meta plans to move to a centrally managed Argo CD service to cut maintenance overhead across the fleet. It is also exploring upstream contributions on container registry authentication and on Argo CD performance in large clusters. Running a GitOps controller per cluster at this scale has a cost, and Meta is still paying it.&lt;/p&gt;

&lt;h2&gt;
  
  
  How popular tools handle promotion across clusters
&lt;/h2&gt;

&lt;p&gt;Meta's pattern has two parts: a reconciler that keeps clusters matching Git, and a promotion layer that decides when a version moves to the next environment. Tools split that work differently.&lt;/p&gt;

&lt;p&gt;Argo CD is the reconciler Meta chose. ApplicationSets let one definition fan out across many clusters, and the web UI shows sync and health state per application. Argo CD has no promotion model of its own.&lt;/p&gt;

&lt;p&gt;Kargo fills that gap for Argo CD users. It models environments as stages and promotes versioned artifacts between them. If you already run Argo CD, it is the shortest path to what Meta built.&lt;/p&gt;

&lt;p&gt;Flux is the other CNCF-graduated GitOps reconciler. It is built as a set of controllers, and its image automation controllers can write new image tags back to Git. Teams that prefer composing small controllers over running one larger application tend to pick it.&lt;/p&gt;

&lt;p&gt;Spinnaker takes the push-based pipeline route, with deploy stages, manual judgment gates and automated canary analysis. It handles multi-cloud promotion well. It is also a heavy system to operate.&lt;/p&gt;

&lt;p&gt;GitHub Actions and GitLab CI/CD both offer environments with protection rules and approval gates, and work well when the deploy logic already lives next to the code. Both push to the cluster from a runner, so they don't correct drift in the cluster between deploys.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://buddy.works/?utm_source=cicd.deployment.to&amp;amp;utm_medium=article&amp;amp;utm_campaign=meta-gitops-argo-kargo" rel="noopener noreferrer"&gt;Buddy&lt;/a&gt; is also push-based. It chains Kubernetes and Helm deploy actions with manual approval steps in one pipeline, and you can build and edit that pipeline in a UI or in YAML. The concrete reason to look at it here is team size. A small team with a handful of clusters can get gated, per-environment promotion without installing and upgrading a controller in every cluster.&lt;/p&gt;

&lt;p&gt;At Meta's scale, a pull-based reconciler is the better fit. With around 100 clusters, in-cluster drift correction and Git as the single record of desired state are worth the operating cost, and Meta's own roadmap shows how large that cost is. A push pipeline only knows what it deployed. It doesn't know what someone changed by hand afterwards.&lt;/p&gt;

&lt;p&gt;Meta says it will keep expanding adoption of the platform. The open question for anyone copying it is the one Meta is working on now: keeping Argo CD fast and maintainable once the fleet gets large.&lt;/p&gt;

</description>
      <category>gitops</category>
      <category>argocd</category>
      <category>kargo</category>
      <category>kubernetes</category>
    </item>
    <item>
      <title>Claude Code's 'Don't ask again' file is leaking tokens into Git repos</title>
      <dc:creator>Leo</dc:creator>
      <pubDate>Thu, 12 Nov 2026 10:23:55 +0000</pubDate>
      <link>https://dev.to/leobaniak/claude-codes-dont-ask-again-file-is-leaking-tokens-into-git-repos-ehd</link>
      <guid>https://dev.to/leobaniak/claude-codes-dont-ask-again-file-is-leaking-tokens-into-git-repos-ehd</guid>
      <description>&lt;p&gt;When a developer picks "Yes, and don't ask again" in Claude Code, the exact shell command is saved to &lt;code&gt;.claude/settings.local.json&lt;/code&gt; in the project folder. If that command carried a token, the token now sits in a plain file one &lt;code&gt;git add .&lt;/code&gt; away from a remote. GitLab published a guide on November 11 covering prevention, exposure assessment and cleanup.&lt;/p&gt;

&lt;p&gt;The problem is already measurable. In early November 2026, Apiiro reported 104,185 copies of the file in public repositories, per the GitLab post. Of those, 1,122 held at least one secret. GitLab adds that hundreds more secrets survived only in history, in files that had since been deleted. GitLab says its own infrastructure secrets are protected.&lt;/p&gt;

&lt;h2&gt;
  
  
  How the file gets committed
&lt;/h2&gt;

&lt;p&gt;The file is an allowlist. Claude Code records approved commands under &lt;code&gt;permissions.allow&lt;/code&gt; so the agent can rerun them without asking again. An entry for a test runner is harmless. A &lt;code&gt;curl&lt;/code&gt; call with a token in the header is a stored credential.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nl"&gt;"permissions"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nl"&gt;"allow"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;
      &lt;span class="s2"&gt;"Bash(npm test:*)"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
      &lt;span class="s2"&gt;"Bash(curl --header \"PRIVATE-TOKEN: &amp;lt;your-token&amp;gt;\" ...)"&lt;/span&gt;
    &lt;span class="p"&gt;]&lt;/span&gt;
  &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Claude Code does try to keep the file out of version control. It does that through the developer's personal global excludes, not the project's &lt;code&gt;.gitignore&lt;/code&gt;. A global excludes file is Git configuration on one machine. It applies on that machine only and does not travel with the repository. A rebuilt laptop or a fresh dev container starts without it, and the repository has no rule of its own to fall back on.&lt;/p&gt;

&lt;h2&gt;
  
  
  Four controls, set once
&lt;/h2&gt;

&lt;p&gt;GitLab's guide stacks four prevention layers. Per the post, each is a setting a group owner changes once.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;A &lt;code&gt;.gitignore&lt;/code&gt; entry for &lt;code&gt;.claude/settings.local.json&lt;/code&gt;, added to repositories and to group file templates. All tiers.&lt;/li&gt;
&lt;li&gt;A push rule that rejects the file by path, using the regex &lt;code&gt;(^|/)\.claude/settings\.local\.json$&lt;/code&gt;. Premium and Ultimate.&lt;/li&gt;
&lt;li&gt;Secret Push Protection, which rejects pushes containing known token formats regardless of filename. Ultimate.&lt;/li&gt;
&lt;li&gt;A scan execution policy that runs GitLab Secret Detection in every project. Setting &lt;code&gt;SECRET_DETECTION_HISTORIC_SCAN: 'true'&lt;/code&gt; extends the scan to history. Ultimate.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Two caveats from the post decide the rollout order. Push rules check only newly added files, so a file that is already tracked passes. Clean up first, then turn the rule on. Group-level push rules also apply only to projects created afterwards. Existing projects need the rule configured one by one, which is toil worth scripting.&lt;/p&gt;

&lt;p&gt;Layers 1 and 2 match a path. Layers 3 and 4 match content, and they look for known token formats. A credential in a format the scanner does not recognise gets past both content checks. The path rules are what catch it.&lt;/p&gt;

&lt;h2&gt;
  
  
  Checking for exposure
&lt;/h2&gt;

&lt;p&gt;The guide gives three routes, depending on tier.&lt;/p&gt;

&lt;p&gt;With GitLab Duo, Agentic Chat can query commit history across projects and report current and deleted copies of the file along with the secret types involved.&lt;/p&gt;

&lt;p&gt;Without Duo, Premium and Ultimate customers can use code search. With Zoekt the query is &lt;code&gt;file:\.claude/settings\.local\.json$&lt;/code&gt;. With Elasticsearch it is &lt;code&gt;filename:settings.local.json path:.claude&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;On any tier, the Commits API works:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight http"&gt;&lt;code&gt;&lt;span class="na"&gt;GET /api/v4/projects/&amp;lt;id&amp;gt;/repository/commits?path&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;claude&lt;/span&gt;&lt;span class="o"&gt;/&lt;/span&gt;&lt;span class="n"&gt;settings&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;local&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;json&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="n"&gt;all&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="kc"&gt;true&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="n"&gt;follow&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="kc"&gt;false&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Keep &lt;code&gt;follow=false&lt;/code&gt;. The post warns that without it, the call can return empty results for repositories with more than one page of commits. In an audit script, an empty result looks like a clean repository, which is the worst way for it to fail.&lt;/p&gt;

&lt;h2&gt;
  
  
  Cleanup order
&lt;/h2&gt;

&lt;p&gt;Rotate first. GitLab's guide says to rotate every exposed secret at its source provider before touching any files. Deleting the file does nothing for a token that was already pushed.&lt;/p&gt;

&lt;p&gt;Then remove the file and add the &lt;code&gt;.gitignore&lt;/code&gt; entry. Then purge history under Settings &amp;gt; Repository &amp;gt; Repository maintenance &amp;gt; Remove blobs, run housekeeping, and allow about 30 minutes for objects to be pruned. Forks keep their own copies and need the same assessment and cleanup separately.&lt;/p&gt;

&lt;p&gt;Until each repository has its own ignore rule, a clone is only as safe as the Git config on the machine that cloned it.&lt;/p&gt;

</description>
      <category>secrets</category>
      <category>secretscanning</category>
      <category>aiagents</category>
      <category>claudecode</category>
    </item>
    <item>
      <title>Adrian Roselli's Interop 2027 ballot ranks the places authors keep getting it wrong</title>
      <dc:creator>Leo</dc:creator>
      <pubDate>Wed, 11 Nov 2026 16:08:09 +0000</pubDate>
      <link>https://dev.to/leobaniak/adrian-rosellis-interop-2027-ballot-ranks-the-places-authors-keep-getting-it-wrong-4ong</link>
      <guid>https://dev.to/leobaniak/adrian-rosellis-interop-2027-ballot-ranks-the-places-authors-keep-getting-it-wrong-4ong</guid>
      <description>&lt;p&gt;Somewhere right now a screen reader user is on a page where an announcement never came, or came three times. Somewhere a keyboard user is pressing Tab through a toolbar one button at a time because nobody wired up the arrow keys. Most people in their position will never see an Interop ballot. They live with whatever ends up on it.&lt;/p&gt;

&lt;p&gt;Adrian Roselli has published his. Interop 2027 is gathering votes until 19 November 2026, and for the second year Firefox has put up a page that lets anyone rank the proposals. Roselli narrowed his choices to fifteen and wrote a sentence or two of reasoning for each. Nearly every reason starts from a user who gets stranded. That makes his list a useful second opinion if you haven't voted yet.&lt;/p&gt;

&lt;h2&gt;
  
  
  The top of the list is about taking script away from us
&lt;/h2&gt;

&lt;p&gt;Roselli says plainly that "the top three are really what matter." All three replace something authors currently build by hand and frequently break.&lt;/p&gt;

&lt;p&gt;&lt;code&gt;ariaNotify()&lt;/code&gt; is his first pick. His case rests on "years of watching developers get live regions wrong," which he argues is partly because companies aren't employing screen reader users in critical roles, combined with confusion about how live regions are exposed and supported. He notes that the ARIA Working Group put a lot of effort into specifying &lt;code&gt;ariaNotify()&lt;/code&gt;, and he wants broad support to follow.&lt;/p&gt;

&lt;p&gt;The HTML &lt;code&gt;focusgroup&lt;/code&gt; attribute is second. Roselli expects it to simplify keyboard patterns for authors, "and hopefully less scripting," with better outcomes for users. He has written about his &lt;code&gt;focusgroup&lt;/code&gt; testing before, so this is not a pick made on paper.&lt;/p&gt;

&lt;p&gt;Shadow DOM &lt;code&gt;referenceTarget&lt;/code&gt; is third. His reason is the one I'd underline for anyone shipping web components: he has seen "so many broken associations across shadow boundaries that have left screen reader and voice control users stranded." ARIA reflection and the proposed AOM continue to get some attention, he writes, but "they aren't here today."&lt;/p&gt;

&lt;p&gt;Read those three together and the pattern is clear. Each is a job that today depends on every author, in every codebase, getting the details right. Each moves that job into the browser, where it gets done once. That is the &lt;strong&gt;use-the-platform argument&lt;/strong&gt; at the scale of the whole web, and it is why I'd put these three at the top too.&lt;/p&gt;

&lt;h2&gt;
  
  
  Picks he makes while wary of them
&lt;/h2&gt;

&lt;p&gt;The more honest part of the post is where Roselli ranks a feature and names the way it could go wrong in the same breath.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;He ranks the HTML &lt;code&gt;headingoffset&lt;/code&gt; and &lt;code&gt;headingreset&lt;/code&gt; attributes fourth, because headings in user-generated or third-party content are often the wrong level. He also says those wrong levels aren't typically blockers, and his fear is that authors will get more cavalier, even treating the attributes as an outline algorithm.&lt;/li&gt;
&lt;li&gt;He ranks &lt;code&gt;line-clamp&lt;/code&gt; because card designs have been clipping text visually or moving interactive controls to the wrong place for years, which he says makes for confusing interfaces for keyboard and screen reader users. He is still wary of letting CSS generate content, citing localization risk.&lt;/li&gt;
&lt;li&gt;On &lt;code&gt;random-item()&lt;/code&gt;, he writes that not needing script would be nice, but authors may use it for more than basic styling, which could interfere with what is exposed to accessibility APIs.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;That is how I'd want anyone to vote. A feature can be worth ranking and still need watching once it ships. Ranking &lt;code&gt;headingoffset&lt;/code&gt; does not change the fact that the heading level you write should match the structure of the page.&lt;/p&gt;

&lt;h2&gt;
  
  
  The rest of the fifteen
&lt;/h2&gt;

&lt;p&gt;The lower half is a mix of user-facing fixes and things Roselli wants as an author:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Device Posture API and Viewport Segments API, because new hardware is already causing problems for design systems that, in his view wrongly, rely on known and fixed screen sizes.&lt;/li&gt;
&lt;li&gt;CSS linked parameters, so he can pass colors into SVGs referenced by &lt;code&gt;&amp;lt;img&amp;gt;&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;CSS &lt;code&gt;AccentColor&lt;/code&gt; system color reflects &lt;code&gt;accent-color&lt;/code&gt;, because some design systems that leaned on this user preference are, after fingerprinting concerns, stuck with low-contrast browser defaults.&lt;/li&gt;
&lt;li&gt;HTML &lt;code&gt;&amp;lt;input type="week"&amp;gt;&lt;/code&gt;, given how many poorly-coded, inaccessible date pickers he has seen. "I've yet to see an author get it right," he writes.&lt;/li&gt;
&lt;li&gt;CSS anchor positioning with transforms and animations, since the script needed to do it well makes his phone overheat.&lt;/li&gt;
&lt;li&gt;CSS &lt;code&gt;flex-wrap: balance&lt;/code&gt;, to close what he calls a years-old gap in flex.&lt;/li&gt;
&lt;li&gt;Responsive iframes, which he treats as an accessibility issue once critical content is visually hidden, scrollbars or not.&lt;/li&gt;
&lt;li&gt;Interoperability of pointer events on touch devices, which made the list only because Apple is making a touch-screen Mac and he would rather the interoperability work arrive first.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;He also says there are items he would down-vote if he could, and he links the rankings of nineteen other people who have published theirs.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where I land
&lt;/h2&gt;

&lt;p&gt;Roselli's ballot is the one I'd hand to someone who builds components for a living, because every entry is tied to a real failure rather than to novelty. The top three deserve the weight he gives them. Each turns a pattern that authors re-implement badly into something the platform owns.&lt;/p&gt;

&lt;p&gt;If you are voting before 19 November:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;put features that replace scripted widgets and hand-wired ARIA near the top&lt;/li&gt;
&lt;li&gt;for anything that styles or generates content, ask what it could do to the accessibility tree before you rank it&lt;/li&gt;
&lt;li&gt;read one or two of the rankings he links that disagree with yours&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;His last line on those other lists is the right spirit for the whole exercise: "None of those rankings are wrong. Except where they are wrong, of course."&lt;/p&gt;

</description>
      <category>interop2027</category>
      <category>a11y</category>
      <category>aria</category>
      <category>html</category>
    </item>
    <item>
      <title>GitHub secret scanning now reads your Actions logs, once the run is over</title>
      <dc:creator>Leo</dc:creator>
      <pubDate>Tue, 10 Nov 2026 10:23:50 +0000</pubDate>
      <link>https://dev.to/leobaniak/github-secret-scanning-now-reads-your-actions-logs-once-the-run-is-over-11cp</link>
      <guid>https://dev.to/leobaniak/github-secret-scanning-now-reads-your-actions-logs-once-the-run-is-over-11cp</guid>
      <description>&lt;p&gt;Somewhere in your org there is a build log with a live credential in it. Nobody put it there on purpose. A debug flag, a verbose CLI, a token that got base64-encoded on its way to stdout, and now it sits in a log that everyone with read access can open. GitHub's answer, now in public preview, is to have secret scanning read those logs for you.&lt;/p&gt;

&lt;h2&gt;
  
  
  The release, line by line
&lt;/h2&gt;

&lt;p&gt;Secret scanning already covered issues, wikis, discussions and pull requests. It now covers GitHub Actions workflow logs too. When a workflow run completes, GitHub scans its logs for provider patterns. Findings land in the repository's secret scanning alert list, next to the alerts from code and other content, with a link back to the workflow log that leaked.&lt;/p&gt;

&lt;p&gt;The rest of the changelog:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Validity checks run for supported secret types, so you can see whether the leaked credential still works.&lt;/li&gt;
&lt;li&gt;Alerts stay around after the logs are deleted.&lt;/li&gt;
&lt;li&gt;The preview is for enterprises on GitHub Enterprise Cloud with GitHub Secret Protection or GitHub Advanced Security, including those with data residency on GHE.com.&lt;/li&gt;
&lt;li&gt;The policy is disabled by default, and it only applies to repositories that already have secret scanning enabled.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Why the log, of all places?
&lt;/h2&gt;

&lt;p&gt;Because the log is where the masking gives up. Actions redacts secrets it knows about, the ones you registered or masked yourself. It redacts them by matching the exact string. Transform the value (encode it, slice it, wrap it in JSON, let a tool echo back an exchanged token) and the match fails. The redaction never sees it. Then &lt;code&gt;set -x&lt;/code&gt; or a chatty deploy CLI prints the result, and the log keeps it for as long as your retention policy says.&lt;/p&gt;

&lt;p&gt;So the trust boundary here is read access to Actions logs, which is usually a much wider group than the group that can see your secrets. A scanner that checks every completed run turns a quiet exposure into a tracked alert. That part is good. Credit where due.&lt;/p&gt;

&lt;p&gt;Deleting the log does not close the alert, which is right. A deleted log is not a rotated key.&lt;/p&gt;

&lt;h2&gt;
  
  
  Turning it on
&lt;/h2&gt;

&lt;p&gt;There is no YAML change. An enterprise owner goes to the enterprise settings, then Policies &amp;gt; Advanced Security, and picks &lt;strong&gt;Enabled&lt;/strong&gt; in the All repositories dropdown. Repositories without secret scanning enabled are unaffected.&lt;/p&gt;

&lt;p&gt;While you are at it, mask derived values yourself. The scanner reports a leak after the fact. A mask stops it from being printed at all:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;Exchange a short-lived token&lt;/span&gt;
  &lt;span class="na"&gt;run&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;|&lt;/span&gt;
    &lt;span class="s"&gt;TOKEN="$(./scripts/exchange-token.sh)"&lt;/span&gt;
    &lt;span class="s"&gt;echo "::add-mask::$TOKEN"&lt;/span&gt;
    &lt;span class="s"&gt;echo "DEPLOY_TOKEN=$TOKEN" &amp;gt;&amp;gt; "$GITHUB_ENV"&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Mask first, export second. Get the order wrong and the value is printed before the mask exists.&lt;/p&gt;

&lt;h2&gt;
  
  
  Read the exclusions before you relax
&lt;/h2&gt;

&lt;p&gt;The changelog is upfront about the limits, so be upfront with yourself about them.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Only runs that complete after you enable it get scanned. Your existing logs are not backfilled. Whatever leaked before you flipped the switch stays where it is.&lt;/li&gt;
&lt;li&gt;Generic patterns, custom patterns, AI-detected secrets and already-masked secrets are excluded. Your internal API keys, which only a custom pattern would catch, are invisible to this feature.&lt;/li&gt;
&lt;li&gt;Alerts don't send notifications during the preview. Someone has to open the alert list and look. (Every security team's favourite workflow: remembering.)&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Put together, this covers well-known provider credentials that slipped past masking in new runs, and that is all it covers. That is useful. It also turns into a false sense of coverage if your dashboard says "log scanning: on" and nobody reads the alerts.&lt;/p&gt;

&lt;h2&gt;
  
  
  What other CI systems do with leaked values
&lt;/h2&gt;

&lt;p&gt;Most CI platforms handle this at print time:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;GitLab CI/CD masks variables flagged as masked in job logs, and requires the value to meet format rules before it can be masked.&lt;/li&gt;
&lt;li&gt;Jenkins, through the Credentials Binding plugin, masks bound credentials in console output.&lt;/li&gt;
&lt;li&gt;CircleCI masks project and context environment variables in job output.&lt;/li&gt;
&lt;li&gt;GitHub Actions itself masks registered secrets and anything passed to &lt;code&gt;::add-mask::&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;All four share the weakness above: they match the exact value, so a transformed secret gets through. Reading the finished log is a second net behind the first. Neither one replaces short-lived credentials. A token that expires in an hour cannot do much harm in a log that lives for months.&lt;/p&gt;

&lt;h2&gt;
  
  
  Verdict
&lt;/h2&gt;

&lt;p&gt;Turn it on if you're eligible. It costs nothing and catches the leaks masking misses. Then do the less pleasant work: rotate whatever it finds, move long-lived keys to federation, and give someone the job of checking an alert list that won't notify anyone. By the time the scanner finds a secret, the log has been readable by everyone with repo access. Treat each alert as a key that is already compromised.&lt;/p&gt;

</description>
      <category>githubactions</category>
      <category>secretscanning</category>
      <category>cilogs</category>
      <category>secretsmanagement</category>
    </item>
    <item>
      <title>Your chat UI streams beautifully. A screen reader hears nothing.</title>
      <dc:creator>Leo</dc:creator>
      <pubDate>Sun, 08 Nov 2026 16:07:52 +0000</pubDate>
      <link>https://dev.to/leobaniak/your-chat-ui-streams-beautifully-a-screen-reader-hears-nothing-4pfj</link>
      <guid>https://dev.to/leobaniak/your-chat-ui-streams-beautifully-a-screen-reader-hears-nothing-4pfj</guid>
      <description>&lt;p&gt;A sighted user types a prompt and watches the reply roll in, word after word. A screen reader user types the same prompt and gets silence. Nothing told their software that anything arrived. Eric Bailey's new piece in Smashing Magazine starts from that gap, and his framing is one I agree with completely: "There is nothing special about chat-based UIs when viewed via the lens of the Web Content Accessibility Guidelines."&lt;/p&gt;

&lt;p&gt;So this is not a new discipline. It is the same toolkit (live regions, headings, landmarks, focus management) applied to an interface that has spread fast and mostly been designed for the eye. Here is how each piece fits together.&lt;/p&gt;

&lt;h2&gt;
  
  
  One live region, announced once
&lt;/h2&gt;

&lt;p&gt;The first mistake is the obvious one: putting &lt;code&gt;aria-live&lt;/code&gt; on every message. Bailey's recommendation is a single dedicated live region placed at the end of the DOM, set to &lt;code&gt;aria-live="assertive"&lt;/code&gt;, which your code fills when there is something to say. He points to TetraLogical's write-up on the technique for the implementation details.&lt;/p&gt;

&lt;p&gt;Timing matters as much as placement. Announcing the reply while it streams "may create a juddering and confusing experience that's difficult for someone to parse," he writes. Wait until streaming is done, then announce the whole message.&lt;/p&gt;

&lt;p&gt;The wait before a reply needs handling too. If the screen shows text such as "Thinking", announce that exact text. If it shows only an animation, Bailey suggests announcing "Loading" five seconds after the prompt is sent and repeating every five seconds, varying the wording ("Researching", "Planning") so the person knows work is still happening. He says the five-second figure comes from the inclusive user research he evaluated.&lt;/p&gt;

&lt;p&gt;What about &lt;code&gt;ariaNotify()&lt;/code&gt;? Bailey notes that Baseline lists the method as having cross-browser availability, and he calls it a much-needed addition. He still advises holding off for now. People who rely on assistive technology tend to be slow to upgrade, for good reason: breaking the tool you use to operate your computer is a serious risk. He also has doubts about how mature the polyfills are.&lt;/p&gt;

&lt;h2&gt;
  
  
  A heading for every turn
&lt;/h2&gt;

&lt;p&gt;Headings are the most popular way screen reader users move through a page, according to Bailey, so he gives each message one. It is visually hidden, and it names the speaker:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight html"&gt;&lt;code&gt;&lt;span class="nt"&gt;&amp;lt;article&amp;gt;&lt;/span&gt;
  &lt;span class="nt"&gt;&amp;lt;hX&lt;/span&gt; 
    &lt;span class="na"&gt;class=&lt;/span&gt;&lt;span class="s"&gt;"sr-only"&lt;/span&gt;
    &lt;span class="na"&gt;aria-label=&lt;/span&gt;&lt;span class="s"&gt;"You said/{agent name} said"&lt;/span&gt;
    &lt;span class="na"&gt;tabindex=&lt;/span&gt;&lt;span class="s"&gt;"-1"&lt;/span&gt;&lt;span class="nt"&gt;&amp;gt;&lt;/span&gt;
    You said:/{agent name} said:
  &lt;span class="nt"&gt;&amp;lt;/hX&amp;gt;&lt;/span&gt;
  &lt;span class="nt"&gt;&amp;lt;div&amp;gt;&lt;/span&gt;
    {message body}
  &lt;span class="nt"&gt;&amp;lt;/div&amp;gt;&lt;/span&gt;
&lt;span class="nt"&gt;&amp;lt;/article&amp;gt;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;hX&lt;/code&gt; stands for whatever heading level fits your document. The prefix does in text what left and right alignment does on screen: it tells you who is talking. Bailey adds the &lt;code&gt;aria-label&lt;/code&gt; as a fallback for screen reader bugs, and &lt;code&gt;tabindex="-1"&lt;/code&gt; lets script move focus to the heading.&lt;/p&gt;

&lt;h2&gt;
  
  
  Landmarks: a short list, used with restraint
&lt;/h2&gt;

&lt;p&gt;Bailey's set is small. &lt;code&gt;nav&lt;/code&gt; holds the session list, &lt;code&gt;main&lt;/code&gt; holds the conversation, &lt;code&gt;form&lt;/code&gt; wraps the prompt input, and &lt;code&gt;aside&lt;/code&gt; holds any sidebar of generated content.&lt;/p&gt;

&lt;p&gt;The anti-pattern is wrapping each message in a &lt;code&gt;section&lt;/code&gt; or another landmark. In his words, they "pollute" the list of landmarks a screen reader can generate, and in a long session that list becomes something you have to wade through. Use headings to move between messages and save landmarks for the major regions.&lt;/p&gt;

&lt;p&gt;The same reasoning rules out the ARIA feed pattern. Bailey's warning is that focus-management corner cases and the expectations of keyboard-only users "work against you" there. &lt;code&gt;article&lt;/code&gt; plus a heading is simpler, and there is no need to make it harder than that.&lt;/p&gt;

&lt;h2&gt;
  
  
  Getting around without a mouse
&lt;/h2&gt;

&lt;p&gt;Put skip links before anything visible: one to the conversation, and think about others for the prompt input and the settings area. Make the conversation list a composite widget, which means one tab stop with arrow keys and Home/End to move through the items, so keyboard and motor-impaired users are not tabbing through dozens of entries.&lt;/p&gt;

&lt;p&gt;Then there is F6. Bailey describes F6/Shift+F6 as an older technique some Windows screen reader users rely on to hop between areas of desktop apps. For a web app he suggests &lt;code&gt;Control+F6&lt;/code&gt; and &lt;code&gt;Control+Shift+F6&lt;/code&gt;; for a native app built with web technologies, plain &lt;code&gt;F6&lt;/code&gt; and &lt;code&gt;Shift+F6&lt;/code&gt;. The mechanics:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Give each landmark an &lt;code&gt;id&lt;/code&gt; and &lt;code&gt;tabindex="-1"&lt;/code&gt;, plus an accessible name via &lt;code&gt;aria-label&lt;/code&gt; or &lt;code&gt;aria-labelledby&lt;/code&gt; for every landmark other than &lt;code&gt;main&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;Add an event listener that cycles focus through them.&lt;/li&gt;
&lt;li&gt;When the prompt region is the target, focus the input itself, not its parent &lt;code&gt;form&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;When the conversation is the target, focus the hidden heading of the latest message. Bailey marks it with a &lt;code&gt;data-last-message&lt;/code&gt; attribute.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Let people tune it
&lt;/h2&gt;

&lt;p&gt;His preferences list is where the piece moves past compliance. Let people switch off announcements for interim steps such as tool calls and code searches while keeping that content on the page. Offer a toggle that cuts animation time to zero and defaults to off when &lt;code&gt;prefers-reduced-motion&lt;/code&gt; is detected. Let people mute sound effects, and make keyboard shortcuts re-bindable. He also asks you to test at larger browser font sizes, because many of these interfaces ship small text.&lt;/p&gt;

&lt;p&gt;For tables and code blocks, he suggests the live region announce a summary rather than the content: a table's subject with its row and column counts, or a code block's filename and line count. The full markup stays in the transcript for anyone who wants to read it properly.&lt;/p&gt;

&lt;h2&gt;
  
  
  My verdict
&lt;/h2&gt;

&lt;p&gt;None of this is exotic, and that is the strength of Bailey's guide. &lt;strong&gt;The chat transcript is a document&lt;/strong&gt;, and the elements built for documents already handle it. Before your next chat-UI PR merges, check that:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;one live region announces each finished reply, never the stream&lt;/li&gt;
&lt;li&gt;every message has a hidden heading that names the speaker&lt;/li&gt;
&lt;li&gt;landmarks mark the major regions only, never individual messages&lt;/li&gt;
&lt;li&gt;a keyboard user can reach the prompt, the transcript and the session list without tabbing through everything&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;His last recommendation is the one I would put first: ask disabled people what they think, and treat them as the experts on their own experience.&lt;/p&gt;

</description>
      <category>a11y</category>
      <category>liveregions</category>
      <category>landmarks</category>
      <category>headings</category>
    </item>
    <item>
      <title>tidy-typography.css is a reset that only touches the text</title>
      <dc:creator>Leo</dc:creator>
      <pubDate>Sat, 07 Nov 2026 16:07:55 +0000</pubDate>
      <link>https://dev.to/leobaniak/tidy-typographycss-is-a-reset-that-only-touches-the-text-5ddb</link>
      <guid>https://dev.to/leobaniak/tidy-typographycss-is-a-reset-that-only-touches-the-text-5ddb</guid>
      <description>&lt;p&gt;You drop a heading into a 300px sidebar. Your fluid type scale runs on &lt;code&gt;vw&lt;/code&gt;, so the heading sizes itself for the whole window. It comes out huge. It wraps onto four lines, and the last line is one word. Then the webfont arrives and the block jumps again.&lt;/p&gt;

&lt;p&gt;Three bugs. All typography. None of them is fixed by the margin-and-box-sizing reset you already ship.&lt;/p&gt;

&lt;p&gt;Stu Robson's new CSS-Tricks article goes after exactly that layer. He has collected the useful modern type declarations into one default stylesheet, tidy-typography.css, covering rendering and fallback rules, fluid sizing, vertical rhythm, wrapping, hyphenation and OpenType detail. Take the whole file or take the one declaration that fixes today's irritation. He is upfront that some of it is experimental and that support is uneven, so it needs guardrails rather than blind inclusion.&lt;/p&gt;

&lt;h2&gt;
  
  
  Size against the column
&lt;/h2&gt;

&lt;p&gt;Robson's point is simple: viewport-based fluid type has no idea how wide its element is. Swap &lt;code&gt;vw&lt;/code&gt; for &lt;code&gt;cqi&lt;/code&gt; and the scale reads the container instead.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight css"&gt;&lt;code&gt;&lt;span class="nc"&gt;.article-container&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nl"&gt;container-type&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nb"&gt;inline-size&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="nd"&gt;:root&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="py"&gt;--step-0&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nf"&gt;clamp&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="m"&gt;1rem&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="m"&gt;0.9rem&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="m"&gt;1&lt;/span&gt;&lt;span class="n"&gt;cqi&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="m"&gt;1.125rem&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
  &lt;span class="py"&gt;--step-3&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nf"&gt;clamp&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="m"&gt;2rem&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="m"&gt;1.6rem&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="m"&gt;3&lt;/span&gt;&lt;span class="n"&gt;cqi&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="m"&gt;2.75rem&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The same heading now fits an article column and a 300px sidebar, without a media query per component.&lt;/p&gt;

&lt;p&gt;One thing to check in devtools. A &lt;code&gt;cqi&lt;/code&gt; length resolves against the nearest container above the element that uses it, and with no container it falls back to the small viewport size. The finished file sets &lt;code&gt;font-size: var(--step-0)&lt;/code&gt; on &lt;code&gt;body&lt;/code&gt;, which sits above any &lt;code&gt;.article-container&lt;/code&gt;. So the headings inside the column get container math. Body copy gets viewport math inside a narrow clamp. That is fine. Just know which one you are looking at.&lt;/p&gt;

&lt;h2&gt;
  
  
  Trim the line box
&lt;/h2&gt;

&lt;p&gt;&lt;code&gt;line-height&lt;/code&gt; adds half-leading above the cap height and below the baseline. You never notice until text has to line up tightly against an icon or a box edge, and then you reach for a negative margin tuned to one font. Robson's replacement measures from the font metrics:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight css"&gt;&lt;code&gt;&lt;span class="nd"&gt;:is&lt;/span&gt;&lt;span class="o"&gt;(&lt;/span&gt;&lt;span class="nt"&gt;h1&lt;/span&gt;&lt;span class="o"&gt;,&lt;/span&gt; &lt;span class="nt"&gt;h2&lt;/span&gt;&lt;span class="o"&gt;,&lt;/span&gt; &lt;span class="nt"&gt;h3&lt;/span&gt;&lt;span class="o"&gt;,&lt;/span&gt; &lt;span class="nt"&gt;h4&lt;/span&gt;&lt;span class="o"&gt;,&lt;/span&gt; &lt;span class="nt"&gt;h5&lt;/span&gt;&lt;span class="o"&gt;,&lt;/span&gt; &lt;span class="nt"&gt;h6&lt;/span&gt;&lt;span class="o"&gt;),&lt;/span&gt; &lt;span class="nt"&gt;p&lt;/span&gt;&lt;span class="o"&gt;,&lt;/span&gt; &lt;span class="nt"&gt;blockquote&lt;/span&gt;&lt;span class="o"&gt;,&lt;/span&gt; &lt;span class="nt"&gt;figcaption&lt;/span&gt;&lt;span class="o"&gt;,&lt;/span&gt; &lt;span class="nt"&gt;li&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="py"&gt;text-box&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;trim-both&lt;/span&gt; &lt;span class="n"&gt;cap&lt;/span&gt; &lt;span class="nb"&gt;alphabetic&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The article also shows the proposed &lt;code&gt;:heading&lt;/code&gt; pseudo-class from Selectors Level 5. Robson says it has not landed in browsers and belongs behind &lt;code&gt;@supports selector(:heading)&lt;/code&gt;. Take that seriously. A plain selector list is all-or-nothing, so one selector the parser doesn't know drops the whole rule, &lt;code&gt;p&lt;/code&gt; and &lt;code&gt;li&lt;/code&gt; included. The finished file spells the headings out with &lt;code&gt;:is()&lt;/code&gt;, which is the version to copy.&lt;/p&gt;

&lt;h2&gt;
  
  
  Wrapping, handed back to CSS
&lt;/h2&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight css"&gt;&lt;code&gt;&lt;span class="nt"&gt;p&lt;/span&gt;&lt;span class="o"&gt;,&lt;/span&gt; &lt;span class="nt"&gt;li&lt;/span&gt;&lt;span class="o"&gt;,&lt;/span&gt; &lt;span class="nt"&gt;dd&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nl"&gt;text-wrap&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;pretty&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
  &lt;span class="nl"&gt;max-width&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="m"&gt;65ch&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="o"&gt;[&lt;/span&gt;&lt;span class="nt"&gt;contenteditable&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s1"&gt;"true"&lt;/span&gt;&lt;span class="o"&gt;]&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nl"&gt;text-wrap&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;stable&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Headings, blockquotes and figcaptions get &lt;code&gt;text-wrap: balance&lt;/code&gt;, which Robson says works best on blocks of up to about six lines. &lt;code&gt;pretty&lt;/code&gt; avoids a stranded last word without rebalancing the whole paragraph. &lt;code&gt;stable&lt;/code&gt; stops editable text from reshuffling the paragraph on every new word. Both replace the JavaScript orphan fixers. Delete them.&lt;/p&gt;

&lt;p&gt;Hyphenation gets the same tuning. &lt;code&gt;hyphens: auto&lt;/code&gt; needs a correct &lt;code&gt;lang&lt;/code&gt; attribute, because without a dictionary the browser can't hyphenate anything. On top of it Robson sets &lt;code&gt;hyphenate-limit-chars: 6 3 3&lt;/code&gt;, &lt;code&gt;hyphenate-limit-lines: 2&lt;/code&gt;, &lt;code&gt;hyphenate-limit-zone: 8%&lt;/code&gt; and &lt;code&gt;hyphenate-limit-last: always&lt;/code&gt;, and adds the &lt;code&gt;-webkit-&lt;/code&gt; equivalents because Safari needs them. Code, &lt;code&gt;kbd&lt;/code&gt;, &lt;code&gt;samp&lt;/code&gt;, &lt;code&gt;var&lt;/code&gt; and headings go back to &lt;code&gt;hyphens: manual&lt;/code&gt;. A broken code word can change its meaning.&lt;/p&gt;

&lt;h2&gt;
  
  
  Let the font do the fine work
&lt;/h2&gt;

&lt;p&gt;This is the part I'd steal first.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;code&gt;font-synthesis: none&lt;/code&gt; stops the browser inventing a bold or italic the family doesn't have.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;font-size-adjust: from-font&lt;/code&gt; uses font metrics to shrink the visible jump when the fallback swaps for the webfont.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;size-adjust: 105%&lt;/code&gt; inside an &lt;code&gt;@font-face&lt;/code&gt; scales a monospace face to match the x-height of the prose around it, without touching &lt;code&gt;font-size&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;A &lt;code&gt;--vf-grad&lt;/code&gt; custom property drops to &lt;code&gt;-50&lt;/code&gt; under &lt;code&gt;prefers-color-scheme: dark&lt;/code&gt; and feeds &lt;code&gt;font-variation-settings: "GRAD" var(--vf-grad, 0)&lt;/code&gt;. Light text on a dark background reads heavier, and the grade axis thins it without changing glyph width. Fonts without the axis ignore it.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;font-variant-position: sub&lt;/code&gt; and &lt;code&gt;super&lt;/code&gt;, wrapped in &lt;code&gt;@supports&lt;/code&gt;, use the font's real sub and superscript glyphs. Robson warns that most typefaces only include numerals for these, so check your font first.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The locale quote rules sit inside &lt;code&gt;:where(:lang(en))&lt;/code&gt; and friends. That's zero specificity, so a project overrides them with one class. &lt;code&gt;:is()&lt;/code&gt; keeps the specificity of its most specific argument. That's the trade between the two.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where to draw the line
&lt;/h2&gt;

&lt;p&gt;Robson's closing caveat is the honest one. Unsupported declarations are ignored, so the file can go in gradually, but that only helps when the unenhanced text already looks acceptable. He expects support to keep moving, especially for &lt;code&gt;text-wrap&lt;/code&gt; and &lt;code&gt;text-box-trim&lt;/code&gt;. And a news article, a marketing page and an editable product UI don't ask the same things of their text.&lt;/p&gt;

&lt;p&gt;So don't paste all of it. Start with &lt;code&gt;font-synthesis: none&lt;/code&gt; and &lt;code&gt;text-wrap: pretty&lt;/code&gt; on your next project. Then open the sidebar again and see whether that heading still needs its media query.&lt;/p&gt;

</description>
      <category>css</category>
      <category>typography</category>
      <category>cssreset</category>
      <category>textwrap</category>
    </item>
    <item>
      <title>October's Node.js fixes have to land in Azure Pipelines more than once</title>
      <dc:creator>Leo</dc:creator>
      <pubDate>Sat, 07 Nov 2026 10:23:23 +0000</pubDate>
      <link>https://dev.to/leobaniak/octobers-nodejs-fixes-have-to-land-in-azure-pipelines-more-than-once-4l9j</link>
      <guid>https://dev.to/leobaniak/octobers-nodejs-fixes-have-to-land-in-azure-pipelines-more-than-once-4l9j</guid>
      <description>&lt;p&gt;Ten Node.js vulnerabilities fixed on October 21 have to be patched in Azure Pipelines more than once, because Node.js sits in several layers of a pipeline and each layer updates on its own. That is the core of security guidance Microsoft published on November 5 on the Azure DevOps Blog. The fixed releases are Node.js 22.23.4, 24.22.1 and 26.12.1.&lt;/p&gt;

&lt;p&gt;The bugs most relevant to build infrastructure sit in name and certificate handling. CVE-2026-105482 can truncate a DNS name containing a NUL character after a full-name security check has already passed. CVE-2026-105483, CVE-2026-106069 and CVE-2026-106072 let unusual IP address spellings get past certificate identity checks. CVE-2026-111497 is a Brotli decompression bug that can corrupt memory when attacker-controlled data reaches an affected decoder. Per the guidance, the same Brotli CVE is also fixed in .NET, with patched baselines of 8.0.33, 9.0.22 and 10.0.14.&lt;/p&gt;

&lt;h2&gt;
  
  
  Each copy has its own owner
&lt;/h2&gt;

&lt;p&gt;The agent comes first. Self-hosted agent v5.281.1, released October 23, moves its bundled Node24 runner to 24.22.1, and Microsoft says to roll it out through the supported agent-pool update process. Azure DevOps Server installations should follow the agent support for their release instead of installing this agent everywhere.&lt;/p&gt;

&lt;p&gt;Next is the Node.js a pipeline picks for itself. Both UseNode@1 and NodeTool@0 default &lt;code&gt;checkLatest&lt;/code&gt; to false. Microsoft's advice is to select a fixed release, or a later supported patch in the same major line, and keep that selection current.&lt;/p&gt;

&lt;p&gt;Task and extension publishers need to update handlers and dependencies and publish new versions. Consumers should move to compatible, supported versions without forcing incompatible tasks onto Node24. Job containers and deployed applications are serviced separately again: update the runtime or image inputs, rebuild, redeploy, then verify the running version.&lt;/p&gt;

&lt;h2&gt;
  
  
  Check the binary, not the label
&lt;/h2&gt;

&lt;p&gt;For Microsoft-hosted agents, the guidance warns against assuming patch status from an image label. Verify the job image, the agent and the executable that actually ran. Microsoft names two commands for it:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;script&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="pi"&gt;|&lt;/span&gt;
    &lt;span class="s"&gt;node --version&lt;/span&gt;
    &lt;span class="s"&gt;node -p "process.execPath"&lt;/span&gt;
  &lt;span class="na"&gt;displayName&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;Report the Node.js this step resolved&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The version line answers whether the step got a fixed release. The path line answers which installed copy it came from, which is what tells you whether the agent, a tool task or the image supplied it.&lt;/p&gt;

&lt;p&gt;Updating the agent pool closes one path. Containers and applications already deployed keep running the Node.js they were built with until someone rebuilds them.&lt;/p&gt;

</description>
      <category>node</category>
      <category>cve</category>
      <category>azurepipelines</category>
      <category>vulnerabilitymanagement</category>
    </item>
    <item>
      <title>Rebuilding :nth-child() out of sibling-index(), if() and mod()</title>
      <dc:creator>Leo</dc:creator>
      <pubDate>Fri, 06 Nov 2026 16:07:08 +0000</pubDate>
      <link>https://dev.to/leobaniak/rebuilding-nth-child-out-of-sibling-index-if-and-mod-434c</link>
      <guid>https://dev.to/leobaniak/rebuilding-nth-child-out-of-sibling-index-if-and-mod-434c</guid>
      <description>&lt;p&gt;You wrote &lt;code&gt;:nth-child(3n + 5)&lt;/code&gt; in a stylesheet. Now a design token says it should be every fourth item from the second. So you edit the selector. Then the selector in the media query. Then the one in the component variant.&lt;/p&gt;

&lt;p&gt;The &lt;code&gt;An + B&lt;/code&gt; numbers live inside the selector, and a selector can't read a custom property. That's the itch Temani Afif scratches in a new CSS-Tricks article. He rebuilds the &lt;code&gt;:nth-child()&lt;/code&gt; patterns as value-level logic, using &lt;code&gt;sibling-index()&lt;/code&gt;, the &lt;code&gt;if()&lt;/code&gt; function with &lt;code&gt;style()&lt;/code&gt; queries, and &lt;code&gt;mod()&lt;/code&gt;. Once the numbers are custom properties, you can change them from anywhere the cascade reaches.&lt;/p&gt;

&lt;h2&gt;
  
  
  From selector to condition
&lt;/h2&gt;

&lt;p&gt;Every example in the article uses the same markup: a &lt;code&gt;.container&lt;/code&gt; with a run of plain &lt;code&gt;div&lt;/code&gt; children. Nothing to see there. The interesting part is where the logic moves.&lt;/p&gt;

&lt;p&gt;&lt;code&gt;sibling-index()&lt;/code&gt; gives an element its position among its siblings as a number. Feed that number to a &lt;code&gt;style()&lt;/code&gt; query inside &lt;code&gt;if()&lt;/code&gt; and you get a per-element condition that sits in the declaration, not the selector. Here's the single-element case, the equivalent of &lt;code&gt;:nth-child(5)&lt;/code&gt;:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight css"&gt;&lt;code&gt;&lt;span class="nc"&gt;.container&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="py"&gt;--B&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="m"&gt;5&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="nc"&gt;.container&lt;/span&gt; &lt;span class="nt"&gt;div&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nl"&gt;background&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;if&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;style&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;sibling-index&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="err"&gt;=&lt;/span&gt; &lt;span class="l"&gt;--B&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt; &lt;span class="nx"&gt;red&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="py"&gt;else&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nx"&gt;lightblue&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Every &lt;code&gt;div&lt;/code&gt; matches the selector. Each one then works out its own background. The fifth one ends up red.&lt;/p&gt;

&lt;p&gt;Swap &lt;code&gt;=&lt;/code&gt; for &lt;code&gt;&amp;gt;=&lt;/code&gt; and you have &lt;code&gt;:nth-child(n + B)&lt;/code&gt;, everything from position B onward. Swap it for &lt;code&gt;&amp;lt;=&lt;/code&gt; and you have &lt;code&gt;:nth-child(-n + B)&lt;/code&gt;, the first B items. Same rule, one character changed. The article also builds a range version with two variables, an &lt;code&gt;--X&lt;/code&gt; and a &lt;code&gt;--Y&lt;/code&gt;, that marks every item between the two positions.&lt;/p&gt;

&lt;h2&gt;
  
  
  The modulo trick
&lt;/h2&gt;

&lt;p&gt;Step patterns need arithmetic. &lt;code&gt;:nth-child(An)&lt;/code&gt; means "every Ath element", which is a polite way of saying the index divides cleanly by A. That's what &lt;code&gt;mod()&lt;/code&gt; checks:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight css"&gt;&lt;code&gt;&lt;span class="nc"&gt;.container&lt;/span&gt; &lt;span class="nt"&gt;div&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nl"&gt;background&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;if&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;style&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;mod&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;sibling-index&lt;/span&gt;&lt;span class="p"&gt;(),&lt;/span&gt; &lt;span class="nf"&gt;var&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="l"&gt;--A&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt; &lt;span class="err"&gt;=&lt;/span&gt; &lt;span class="m"&gt;0&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt; &lt;span class="nx"&gt;red&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Set &lt;code&gt;--A: 3&lt;/code&gt; on the container and every third child goes red. Afif also guards the case where &lt;code&gt;--A&lt;/code&gt; is negative, adding a second condition joined with &lt;code&gt;and&lt;/code&gt; so the rule only fires when &lt;code&gt;var(--A) &amp;gt; 0&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;Then he goes for the full &lt;code&gt;An + B&lt;/code&gt;. That one takes a couple of helper custom properties. The first is computed with &lt;code&gt;calc()&lt;/code&gt; from the index, &lt;code&gt;--B&lt;/code&gt; and &lt;code&gt;--A&lt;/code&gt;. The second combines &lt;code&gt;sign()&lt;/code&gt; and &lt;code&gt;mod()&lt;/code&gt; to test whether that value is a whole number and not negative. There's also a branch for when &lt;code&gt;--A&lt;/code&gt; is zero. I won't paste it here. Go read it with devtools open and watch the helper values change from item to item. It's the best part of the article.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why this is worth your time
&lt;/h2&gt;

&lt;p&gt;Here's my take. The real change is not "you can do &lt;code&gt;:nth-child()&lt;/code&gt; without &lt;code&gt;:nth-child()&lt;/code&gt;." It's that position-based styling becomes data.&lt;/p&gt;

&lt;p&gt;A selector is fixed at authoring time. A custom property cascades. It inherits, it gets overridden by a more specific rule, and it can be set inline on one container. Afif names this as the main advantage: you adjust the selection through variables in real time without rewriting a selector. He also argues the conditional reads more naturally than &lt;code&gt;An + B&lt;/code&gt; notation. I agree. &lt;code&gt;sibling-index() &amp;gt;= --B&lt;/code&gt; tells you what it does. &lt;code&gt;n + B&lt;/code&gt; makes you work it out.&lt;/p&gt;

&lt;p&gt;The trade-off is real too. The selector version can apply a whole rule block at once. The &lt;code&gt;if()&lt;/code&gt; version works one declaration at a time, so styling three properties means three &lt;code&gt;if()&lt;/code&gt; calls, or one custom property you branch on. It's more verbose. You get flexibility in exchange.&lt;/p&gt;

&lt;h2&gt;
  
  
  Before you ship it
&lt;/h2&gt;

&lt;p&gt;Afif is upfront here, and you should take it seriously. These are draft CSS features and browser support is limited. Treat this as a lab technique for now. Where &lt;code&gt;:nth-child()&lt;/code&gt; does the job with fixed numbers, keep using &lt;code&gt;:nth-child()&lt;/code&gt;. It works everywhere and needs no explaining in code review.&lt;/p&gt;

&lt;p&gt;He ends with homework: build the &lt;code&gt;:nth-last-child()&lt;/code&gt; version using &lt;code&gt;sibling-count()&lt;/code&gt;. Try it. Counting from the end means working out how far each item sits from the last sibling, and that exercise will teach you more about these functions than another demo would.&lt;/p&gt;

</description>
      <category>css</category>
      <category>nthchild</category>
      <category>siblingindex</category>
      <category>stylequeries</category>
    </item>
    <item>
      <title>Safari Technology Preview 256 gives line-clamp a continue longhand</title>
      <dc:creator>Leo</dc:creator>
      <pubDate>Thu, 05 Nov 2026 16:07:36 +0000</pubDate>
      <link>https://dev.to/leobaniak/safari-technology-preview-256-gives-line-clamp-a-continue-longhand-31co</link>
      <guid>https://dev.to/leobaniak/safari-technology-preview-256-gives-line-clamp-a-continue-longhand-31co</guid>
      <description>&lt;p&gt;You clamp a card excerpt to three lines. It looks right. Then someone drops an absolutely positioned badge into the text after the cut, and the badge either hangs around below the ellipsis or never gets laid out at all. The clamp hid the lines and forgot about the rest of the box.&lt;/p&gt;

&lt;p&gt;Safari Technology Preview 256 keeps working on that box. It came out on November 4 for macOS Golden Gate and macOS Tahoe and covers WebKit changes 323398@main through &lt;a href="mailto:324653@main"&gt;324653@main&lt;/a&gt;. The interesting part is a change to what &lt;code&gt;line-clamp&lt;/code&gt; actually is in this engine.&lt;/p&gt;

&lt;h2&gt;
  
  
  A shorthand with a longhand behind it
&lt;/h2&gt;

&lt;p&gt;The key CSS note: WebKit added support for &lt;code&gt;continue: collapse&lt;/code&gt; with &lt;code&gt;line-clamp&lt;/code&gt;, and the &lt;code&gt;line-clamp&lt;/code&gt; shorthand now sets it.&lt;/p&gt;

&lt;p&gt;A second note in the same build renames a value. The &lt;code&gt;auto&lt;/code&gt; value of the &lt;code&gt;continue&lt;/code&gt; property is now &lt;code&gt;normal&lt;/code&gt;, which the notes say matches the specification.&lt;/p&gt;

&lt;p&gt;Put those together. &lt;code&gt;line-clamp&lt;/code&gt; is a shorthand, and &lt;code&gt;continue&lt;/code&gt; is one of the longhands it writes. That's the mechanism, and the rest of the release makes more sense once you see it that way.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why the plumbing matters
&lt;/h2&gt;

&lt;p&gt;Shorthands follow one cascade rule everywhere. Declaring the shorthand sets each longhand it covers. A later declaration of a single longhand overrides just that piece. So &lt;code&gt;continue&lt;/code&gt; is now its own property in WebKit, with its own computed value, instead of behaviour buried inside one declaration.&lt;/p&gt;

&lt;p&gt;That changes how you debug. When a clamp misbehaves, check &lt;code&gt;continue&lt;/code&gt; in the computed styles alongside &lt;code&gt;line-clamp&lt;/code&gt;. And if a test page from last month says &lt;code&gt;continue: auto&lt;/code&gt;, that value has a new name now. &lt;strong&gt;Rename it.&lt;/strong&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  The two values
&lt;/h2&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight css"&gt;&lt;code&gt;&lt;span class="c"&gt;/* Set for you by the line-clamp shorthand */&lt;/span&gt;
&lt;span class="nc"&gt;.excerpt&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="py"&gt;continue&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nb"&gt;collapse&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="c"&gt;/* The value WebKit used to call auto */&lt;/span&gt;
&lt;span class="nc"&gt;.excerpt-full&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="py"&gt;continue&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nb"&gt;normal&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The notes stop at the values. They show no full clamping recipe, so read this as a map of what exists, not a pattern to ship.&lt;/p&gt;

&lt;h2&gt;
  
  
  What still slipped past the clamp
&lt;/h2&gt;

&lt;p&gt;The &lt;code&gt;line-clamp&lt;/code&gt; fixes from the last preview keep coming:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;A positioned &lt;code&gt;inline-block&lt;/code&gt; after the clamp point stayed visible.&lt;/li&gt;
&lt;li&gt;An absolutely positioned box inside content after the clamp point wasn't laid out.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;line-clamp: auto&lt;/code&gt; now accounts for collapsed block-end margins when it finds the clamp point, and finds that point before balancing content.&lt;/li&gt;
&lt;li&gt;Layout inside a nested scroll container didn't update after its classic scrollbar disappeared, when &lt;code&gt;line-clamp&lt;/code&gt; was used with an absolutely positioned descendant.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;All fixed. Notice the pattern. Positioned descendants show up three times. If your clamped components carry badges or overlays, this is the build to retest them in.&lt;/p&gt;

&lt;p&gt;Grid got some love too. The grid layout engine now computes collapsed tracks for &lt;code&gt;repeat(auto-fit)&lt;/code&gt;, and empty &lt;code&gt;repeat(auto-fit)&lt;/code&gt; tracks now collapse along with their gutters. If an auto-fit row in WebKit ever left you with a gap you couldn't explain, start your retest there.&lt;/p&gt;

&lt;h2&gt;
  
  
  Markers and palettes
&lt;/h2&gt;

&lt;p&gt;Two smaller features, both about text. &lt;code&gt;text-combine-upright&lt;/code&gt; now works on &lt;code&gt;::marker&lt;/code&gt;. A related fix moves outside list markers to the right place in vertical writing modes. Numbered lists in vertical text get better from both ends.&lt;/p&gt;

&lt;p&gt;&lt;code&gt;font-palette-mix()&lt;/code&gt; arrives on Cocoa platforms, and the notes describe it as letting you blend font color palettes. They give no syntax, so I won't guess at one. Cocoa only, per the notes.&lt;/p&gt;

&lt;h2&gt;
  
  
  Two fixes in the accessibility tree
&lt;/h2&gt;

&lt;p&gt;List marker text generated with the &lt;code&gt;content&lt;/code&gt; property wasn't exposed in the accessibility tree. It is now. If you generate marker text in CSS, sighted users saw it and assistive tech didn't, until this build.&lt;/p&gt;

&lt;p&gt;The second fix is about nested frames. VoiceOver couldn't reach the content of an iframe nested inside an iframe with &lt;code&gt;role="none"&lt;/code&gt; or &lt;code&gt;role="presentation"&lt;/code&gt;. Fixed.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where support stands
&lt;/h2&gt;

&lt;p&gt;This is one engine's preview build. The notes make no Baseline claim and neither do I. Treat &lt;code&gt;continue: collapse&lt;/code&gt; and &lt;code&gt;font-palette-mix()&lt;/code&gt; as things to try on a test page. The &lt;code&gt;auto&lt;/code&gt; to &lt;code&gt;normal&lt;/code&gt; rename is the only item that asks you to change code you might already have written.&lt;/p&gt;

&lt;p&gt;What I want is a clamp you never think about. Positioned children hidden, margins respected, one property. This build gets closer. Try it on your worst card first.&lt;/p&gt;

</description>
      <category>safari</category>
      <category>webkit</category>
      <category>stp</category>
      <category>browserrelease</category>
    </item>
    <item>
      <title>CircleCI Functions swap orb shell scripts for compiled steps an agent can check before pushing</title>
      <dc:creator>Leo</dc:creator>
      <pubDate>Thu, 05 Nov 2026 10:23:59 +0000</pubDate>
      <link>https://dev.to/leobaniak/circleci-functions-swap-orb-shell-scripts-for-compiled-steps-an-agent-can-check-before-pushing-inl</link>
      <guid>https://dev.to/leobaniak/circleci-functions-swap-orb-shell-scripts-for-compiled-steps-an-agent-can-check-before-pushing-inl</guid>
      <description>&lt;p&gt;The last time I let a coding agent wire up CI on a side project, it skipped the perfectly good setup step sitting in the registry and wrote its own Node install script. The script worked on the third push. I spent the first two watching red builds and wondering why I'd delegated this at all.&lt;/p&gt;

&lt;p&gt;So I read CircleCI's announcement of Functions with a little more personal interest than usual. CircleCI says that in its testing, agents without Functions bypassed the available orbs and generated their own setup scripts about half the time. That's my side project, measured.&lt;/p&gt;

&lt;h2&gt;
  
  
  The short version of the release
&lt;/h2&gt;

&lt;p&gt;Functions are reusable CI steps that ship as prebuilt, tested code with clearly defined inputs. They're in beta, free during the beta, and available on every CircleCI plan, according to the announcement. You declare them in a new &lt;code&gt;functions:&lt;/code&gt; block and call them by name inside a job:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="na"&gt;version&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="m"&gt;2.1&lt;/span&gt;

&lt;span class="na"&gt;functions&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
  &lt;span class="na"&gt;setup-node&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;github.com/circleci-functions/setup-node@v0.4.0&lt;/span&gt;

&lt;span class="na"&gt;jobs&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
  &lt;span class="na"&gt;test&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;docker&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
      &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;image&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;cimg/base:current&lt;/span&gt;
    &lt;span class="na"&gt;steps&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
      &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="s"&gt;checkout&lt;/span&gt;
      &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;setup-node&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
          &lt;span class="na"&gt;with&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
            &lt;span class="na"&gt;node-version&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="s"&gt;22"&lt;/span&gt;
      &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;run&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;npm test&lt;/span&gt;

&lt;span class="na"&gt;workflows&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
  &lt;span class="na"&gt;main&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;jobs&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
      &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="s"&gt;test&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The beta catalog has ten CircleCI-maintained Functions: &lt;code&gt;setup-node&lt;/code&gt;, &lt;code&gt;setup-python&lt;/code&gt;, &lt;code&gt;setup-go&lt;/code&gt;, &lt;code&gt;setup-ruby&lt;/code&gt;, &lt;code&gt;setup-java&lt;/code&gt;, &lt;code&gt;setup-dotnet&lt;/code&gt;, &lt;code&gt;setup-aws&lt;/code&gt;, &lt;code&gt;setup-docker&lt;/code&gt;, &lt;code&gt;setup-browser-tools&lt;/code&gt; and &lt;code&gt;setup-github-cli&lt;/code&gt;. Writing your own Functions, and step outputs, are listed as planned for later releases.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where an orb command and a Function part ways
&lt;/h2&gt;

&lt;p&gt;Orbs aren't going anywhere. CircleCI says the two coexist, no migration is required and no deprecation of orbs is planned. The difference is in what runs when the step executes.&lt;/p&gt;

&lt;p&gt;An orb command typically runs a shell script. CircleCI's point is that an agent, looking at that command, often can't tell whether the setup step works until a pipeline actually runs it. A Function runs a compiled binary, built for Linux, macOS and Windows, behind a declared set of inputs. If you pass an input it doesn't accept, you get an error that names the problem and lists the inputs it does accept.&lt;/p&gt;

&lt;p&gt;The language setup Functions also cache dependencies by default, and CircleCI says that cache persists even when a job fails, times out or is canceled. That one I'll feel on a flaky test suite, where the retry currently pays the full install again. You can switch it off per step with &lt;code&gt;cache: false&lt;/code&gt; under &lt;code&gt;with:&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;Versions are exact and immutable. Aliases like &lt;code&gt;@latest&lt;/code&gt; or &lt;code&gt;@v1&lt;/code&gt; aren't allowed.&lt;/p&gt;

&lt;h2&gt;
  
  
  How an agent (or you) finds and checks them
&lt;/h2&gt;

&lt;p&gt;Discovery goes through the CircleCI CLI, version 1.8.0 or later, and its built-in MCP server. The CLI side is four commands:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;circleci &lt;span class="k"&gt;function &lt;/span&gt;list            &lt;span class="c"&gt;# browse what exists&lt;/span&gt;
circleci &lt;span class="k"&gt;function &lt;/span&gt;get setup-node  &lt;span class="c"&gt;# inspect its inputs&lt;/span&gt;
circleci &lt;span class="k"&gt;function &lt;/span&gt;add setup-node  &lt;span class="c"&gt;# add it to your config&lt;/span&gt;
circleci config validate          &lt;span class="c"&gt;# check the config before pushing&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;For agent tooling, the CLI can start its MCP server (&lt;code&gt;circleci mcp start&lt;/code&gt;), and the announcement includes enable commands for Cursor, VS Code and Claude Desktop. The whole release is built around that loop. The agent looks up the step, reads its inputs, writes the config and validates it locally, before a single runner minute is spent.&lt;/p&gt;

&lt;p&gt;CircleCI's own numbers from internal testing are that agents set up working pipelines up to twice as fast and used about 40% fewer tokens with Functions, and that a Node setup step compiled to roughly seven times less config than the equivalent orb command. Those are vendor benchmarks, so measure your own pipelines before you quote them.&lt;/p&gt;

&lt;h2&gt;
  
  
  The rough edges I'd plan for
&lt;/h2&gt;

&lt;p&gt;It's a beta with ten Functions, all written by CircleCI. If your setup step is anything more exotic than a language runtime or a common CLI, you're still on orbs or &lt;code&gt;run:&lt;/code&gt; steps until custom Functions arrive.&lt;/p&gt;

&lt;p&gt;A compiled binary is also harder to read than a shell script. When an orb command misbehaves, I can open the script and see the &lt;code&gt;curl&lt;/code&gt; line that broke. With a Function, I'm trusting CircleCI's tests and whatever the error message tells me. For most teams that's a fair trade for setup steps. It's still a trade.&lt;/p&gt;

&lt;p&gt;Exact, immutable versions are good supply-chain hygiene, and they also mean nothing moves until someone bumps the version string. Check whether your update bot understands the new &lt;code&gt;functions:&lt;/code&gt; block before you assume it'll open those PRs for you. The announcement doesn't say.&lt;/p&gt;

&lt;h2&gt;
  
  
  How other CI tools package reusable steps
&lt;/h2&gt;

&lt;p&gt;Typed, versioned, reusable steps aren't new as an idea. What CircleCI is adding is the compiled binary and the agent-facing discovery loop. Here's how the tools I see most often handle the same job.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Tool&lt;/th&gt;
&lt;th&gt;Reusable unit&lt;/th&gt;
&lt;th&gt;How inputs are checked&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;GitHub Actions&lt;/td&gt;
&lt;td&gt;Actions referenced with &lt;code&gt;uses: owner/repo@ref&lt;/code&gt;, inputs declared in &lt;code&gt;action.yml&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;Unknown inputs produce a warning at run time. Tags are mutable, so GitHub recommends pinning to a full commit SHA (&lt;code&gt;@&amp;lt;full-40-char-sha&amp;gt;&lt;/code&gt;).&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;GitLab CI/CD&lt;/td&gt;
&lt;td&gt;CI/CD components from the CI/CD Catalog, pulled in with &lt;code&gt;include: component:&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;spec: inputs:&lt;/code&gt; with types, allowed options and regex, checked when the pipeline is created&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Azure Pipelines&lt;/td&gt;
&lt;td&gt;YAML templates with &lt;code&gt;parameters:&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;Typed parameters and allowed &lt;code&gt;values:&lt;/code&gt; are checked when the template is expanded, before any job runs&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Dagger&lt;/td&gt;
&lt;td&gt;Modules of Dagger Functions written in Go, Python or TypeScript&lt;/td&gt;
&lt;td&gt;Ordinary typed function signatures, and the same call runs on your laptop and in any CI&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Buddy&lt;/td&gt;
&lt;td&gt;Prebuilt actions, each a &lt;code&gt;type:&lt;/code&gt; with its own named fields, usable from the UI or YAML&lt;/td&gt;
&lt;td&gt;Fields are configured per action, and the language runtime usually comes from the container image rather than a setup script&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;If you're on GitLab and want typed, versioned reusable steps today without a beta label, CI/CD components with &lt;code&gt;spec: inputs:&lt;/code&gt; are the better fit than anything in this table. If you want one step definition that runs the same way on a laptop and in two different CI systems, Dagger is.&lt;/p&gt;

&lt;p&gt;The reason I'd look at &lt;a href="https://buddy.works/?utm_source=cicd.deployment.to&amp;amp;utm_medium=article&amp;amp;utm_campaign=circleci-functions" rel="noopener noreferrer"&gt;Buddy&lt;/a&gt; for this particular problem is that a language setup step mostly disappears. A build action names its image, and the runtime is already there, so there's no install script for an agent to rewrite:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;action&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="s"&gt;Run&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;tests"&lt;/span&gt;
  &lt;span class="na"&gt;type&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="s"&gt;BUILD"&lt;/span&gt;
  &lt;span class="na"&gt;docker_image_name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="s"&gt;library/node"&lt;/span&gt;
  &lt;span class="na"&gt;docker_image_tag&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="s"&gt;&amp;lt;node-version&amp;gt;"&lt;/span&gt;
  &lt;span class="na"&gt;execute_commands&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
  &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="s"&gt;npm&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;ci"&lt;/span&gt;
  &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="s"&gt;npm&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;test"&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The flip side is that you pick and maintain the image tag yourself, which is the same bump problem as an exact Function version in a different place.&lt;/p&gt;

&lt;h2&gt;
  
  
  What I'm watching next
&lt;/h2&gt;

&lt;p&gt;Custom Functions. Ten CircleCI-maintained setup steps make a nice demo. The real test is whether a platform team can publish its own internal steps as Functions, so that the agent on a product team reaches for the company's setup step instead of improvising one. If you try the beta with an agent in the loop, I'd like to know whether that half-the-time number moves for you.&lt;/p&gt;

</description>
      <category>circleci</category>
      <category>ciconfig</category>
      <category>reusablesteps</category>
      <category>aiagents</category>
    </item>
    <item>
      <title>Safari 27.3 beta will dark-mode your light site unless your CSS says otherwise</title>
      <dc:creator>Leo</dc:creator>
      <pubDate>Wed, 04 Nov 2026 16:07:35 +0000</pubDate>
      <link>https://dev.to/leobaniak/safari-273-beta-will-dark-mode-your-light-site-unless-your-css-says-otherwise-3h4c</link>
      <guid>https://dev.to/leobaniak/safari-273-beta-will-dark-mode-your-light-site-unless-your-css-says-otherwise-3h4c</guid>
      <description>&lt;p&gt;Here's a number for anyone who shipped a white page in 2026 and called the theme work done. WebKit's announcement says almost 40% of web page loads come from users in dark mode, and only 10% of page loads support it. So a lot of people open your docs at midnight and get a flashlight in the eyes. Safari 27.3 beta now has a fix for that, and you don't get a vote unless you've already written one line of CSS. The feature is Adaptive Dark Mode. When a user turns it on, Safari takes a light website and presents it as dark.&lt;/p&gt;

&lt;h2&gt;
  
  
  Who flips the switch
&lt;/h2&gt;

&lt;p&gt;The user does, not you. According to the post (by Simon Fraser, Luming Yin, Lily Spiniolas, Joanne Pan, Veda Periwal and Jen Simmons, dated November 3), the system appearance has to be set to dark. Then, on a site with a bright background, Safari offers a preview of Adaptive Dark Mode with a "Try" button.&lt;/p&gt;

&lt;p&gt;Then comes the gate. If your page signals dark-mode support with &lt;code&gt;&amp;lt;meta name="color-scheme" content="light dark"&amp;gt;&lt;/code&gt; in HTML or &lt;code&gt;color-scheme: light dark&lt;/code&gt; in CSS, the post says Adaptive Dark Mode "does not change a thing." If it doesn't, Safari analyzes the page and estimates whether it's mostly light or mostly dark. A page that already has a dark background with light text is left alone. A light page gets adapted.&lt;/p&gt;

&lt;p&gt;That makes &lt;code&gt;color-scheme&lt;/code&gt; the deciding property. For most of us it has been a set-and-forget line that makes form controls and scrollbars match the theme. In Safari 27.3 beta it also decides whether the engine recolors your whole page.&lt;/p&gt;

&lt;h2&gt;
  
  
  What happens to your pixels
&lt;/h2&gt;

&lt;p&gt;WebKit built a color matrix that inverts the luminosity of colors while keeping their hue. Light backgrounds go dark, dark text goes light, and light CSS gradients turn dark too. Transformed text aims for the WCAG 4.5:1 contrast ratio. Your pastel landing page gets the Deftones-album-cover treatment, and in theory it stays readable.&lt;/p&gt;

&lt;p&gt;Images are handled case by case:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Most images are left unchanged.&lt;/li&gt;
&lt;li&gt;SVG images are inspected, and their colors are transformed when needed.&lt;/li&gt;
&lt;li&gt;For bitmaps, Safari analyzes the pixel histograms and inverts simple black-and-white logos.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;&amp;lt;canvas&amp;gt;&lt;/code&gt; content is not touched at all.&lt;/li&gt;
&lt;li&gt;Masks and &lt;code&gt;mix-blend-mode&lt;/code&gt; can look wrong on an element whose colors were transformed, so in some cases Adaptive Dark Mode turns those effects off.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The post's cleanup list reads like a museum of 2009 front-end. Swap bitmap logos and icons for SVG. Use solid or gradient colors in CSS instead of tiled background images. Replace image sprites with modern CSS for rounded corners, shadows and button states (I hand-sliced so many of those sprite sheets, and honestly I'll miss them a little). Give content images transparent backgrounds instead of baking the page color into them, and add padding to containers so things don't crowd.&lt;/p&gt;

&lt;h2&gt;
  
  
  Saying yes, saying no, or claiming one corner
&lt;/h2&gt;

&lt;p&gt;If you want full control, ship your own dark mode. Declare it early:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight html"&gt;&lt;code&gt;&lt;span class="nt"&gt;&amp;lt;meta&lt;/span&gt; &lt;span class="na"&gt;name=&lt;/span&gt;&lt;span class="s"&gt;"color-scheme"&lt;/span&gt; &lt;span class="na"&gt;content=&lt;/span&gt;&lt;span class="s"&gt;"light dark"&lt;/span&gt;&lt;span class="nt"&gt;&amp;gt;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;





&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight css"&gt;&lt;code&gt;&lt;span class="nd"&gt;:root&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="py"&gt;color-scheme&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;light&lt;/span&gt; &lt;span class="n"&gt;dark&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The post also lists &lt;code&gt;@media (prefers-color-scheme: dark)&lt;/code&gt;, &lt;code&gt;&amp;lt;picture&amp;gt;&amp;lt;source media="(prefers-color-scheme: dark)"&amp;gt;&lt;/code&gt; and &lt;code&gt;light-dark()&lt;/code&gt; as part of the toolkit, and WebKit describes all of it as widely available today. It also mentions &lt;code&gt;color-mix()&lt;/code&gt;, &lt;code&gt;contrast-color()&lt;/code&gt; and CSS variables for organizing a design system. Put the meta tag in your HTML head, set the property on &lt;code&gt;:root&lt;/code&gt; or &lt;code&gt;body&lt;/code&gt;, or both. WebKit is explicit that you shouldn't inject the declaration later with JavaScript. It belongs in the initial HTML and CSS so the page renders correctly right away.&lt;/p&gt;

&lt;p&gt;Need your own dark styling for just one part of the page? Apply &lt;code&gt;color-scheme: light dark&lt;/code&gt; to that element and write your dark styles for it.&lt;/p&gt;

&lt;p&gt;Want out entirely? Use &lt;code&gt;&amp;lt;meta name="color-scheme" content="light only"&amp;gt;&lt;/code&gt;, or &lt;code&gt;color-scheme: light only&lt;/code&gt; in CSS, either on specific elements or on the whole page through &lt;code&gt;:root&lt;/code&gt;. One catch: &lt;strong&gt;the &lt;code&gt;only&lt;/code&gt; keyword is not supported in Safari 27.3 beta 1.&lt;/strong&gt; The opt-out is documented, but this build doesn't honor it.&lt;/p&gt;

&lt;h2&gt;
  
  
  You can't sniff it, by design
&lt;/h2&gt;

&lt;p&gt;You won't catch this at runtime either. Safari stops websites from detecting that Adaptive Dark Mode is on. JavaScript that queries CSS colors gets the original colors you wrote, and images drawn into a canvas render in their original form. WebKit's reason is fingerprinting: being able to detect the mode would give trackers one more signal. The practical effect is that your declarative CSS is the only thing that counts. There's no analytics event to watch and no runtime patch. Your &lt;code&gt;color-scheme&lt;/code&gt; value is either in the first response or it isn't.&lt;/p&gt;

&lt;h2&gt;
  
  
  Support right now
&lt;/h2&gt;

&lt;p&gt;Adaptive Dark Mode is available only in Safari 27.3 beta, and the &lt;code&gt;only&lt;/code&gt; opt-out isn't there yet in beta 1. WebKit says to check back as the feature evolves through the beta process. The post doesn't say anything about other browsers doing the same thing, so I won't guess.&lt;/p&gt;

&lt;p&gt;Verdict: a solid 8/10 for the engine work and a 2/10 for the sea of light-only pages that made it necessary. Open your &lt;code&gt;&amp;lt;head&amp;gt;&lt;/code&gt;. If there's no &lt;code&gt;color-scheme&lt;/code&gt; in it, this is the week to add one.&lt;/p&gt;

</description>
      <category>darkmode</category>
      <category>colorscheme</category>
      <category>safari</category>
      <category>webkit</category>
    </item>
  </channel>
</rss>
