I had both versions of this demo open side by side this morning. One is the original stagger effect with its custom CSS functions. The other is Lee Meyer's fork, which swaps the whole thing for one declaration. The staggered entrance is the same, with a lot less math.
Here's the news peg. In a CSS-Tricks article published November 16, Meyer responds to a Frontend Masters post by Ashutosh Biswas that staggers scroll-driven animations using what Biswas describes as "a huge formula and can look intimidating." Meyer argues that CSS already has a tool for the job, and that tool is animation-range-start.
Why animation-delay does nothing here
This is the part that trips people up. To stagger a list of time-based animations, you usually give each item a slightly larger animation-delay. Move the same animation onto a scroll timeline and that stops working.
Meyer cites MDN for the reason. animation-delay only means something on the default, time-based document timeline, so it has no effect on scroll-driven animations. What you can offset is the point in scroll progress where the animation starts, and that's the job of animation-range-start. It delays a scroll-driven animation relative to scroll progress rather than time.
So the stagger question changes. You no longer ask how many milliseconds later item four should start. You ask how much further into the range it should start.
The one-liner
Meyer's fork reworks Biswas's demo, an animated donation tally in a site footer where each digit animates in as you scroll. The per-character stagger comes down to this:
animation-range-start: contain calc(10% + 2.5% * sibling-index()); Reading left to right: the animation uses the contain range, every character starts at least 10% into it, and sibling-index() pushes each sibling another 2.5% later. Meyer explains the numbers. The tally has eight characters, and he wanted evenly spaced entrances that end with the last character starting at 30% of the containment range (10% plus 20%).
That's the whole stagger, with no custom functions and no hand-built progress math. For a tighter or looser cascade, change the 2.5%. To start the effect later, change the 10%. The adjustable values are the same numbers you'd sketch on paper, which I like.
Meyer also adds a caveat about the demo itself. Scroll-driven entrances move at the reader's scroll speed, so a quick flick can play the digits too fast to notice. He calls the tally a good case study for comparing scroll-driven and scroll-triggered animation. Because he kept the original behaviour, you have to scroll slowly to see the stagger.
Easing still works on scroll timelines
Biswas's post goes on to build its own easing, saying "we can't use easing keywords or cubic-bezier() or linear() functions here." Meyer disagrees, quoting MDN: "animation-timing-function has the same effect when creating CSS scroll-driven animations as it does for regular time-based animations." He has used steps() on a scroll-driven animation himself, to animate a sprite climbing a ladder in a scrollytelling game.
According to Meyer, the easing problem in the original comes from its structure. Once all the staggered animations are merged into one master timeline, any easing applies to that whole timeline rather than to each element. He calls this a logical consequence of driving everything from one progress value, not a flaw in CSS. In his fork, each character gets its own animation-range-start offset, so there's no merged timeline for the easing to apply to.
Where it runs
Meyer's article has no support table and doesn't give a Baseline status for animation-range-start or sibling-index(). It does say his CodePen fork is for readers using a Chromium-based browser. That's the only browser-support detail the article gives, so check current support data before you rely on the effect in production. A stagger is decoration, so the content should still read fine if the animation never runs.
Meyer is fair to the other side. He says developers have often gotten real results by reimplementing things browsers already do, because it gave them control they couldn't get otherwise. He also points out that scroll timelines are themselves a reinvention of what developers did in JavaScript for decades. His claim is narrower: for this demo, the custom formula was overkill.
What I'm watching next
Meyer ends on the part of Biswas's post he does like: the idea of driving a CSS animation from any progress value, not only time or scroll. His wishlist includes text fields that advance an animation as you fill them in, an animation that tracks how closely a new password matches the required scheme, progress through a quiz or a shopping cart, and a karaoke-style highlight driven by speech recognition. He also suspects Biswas's code may be the closest we're likely to get to that for now.
Custom animation timelines are the thing I'm watching. Until they exist, my next scroll stagger will use animation-range-start and sibling-index().

