This isn't any different than most of the internet standard development. "Rough consensus and running code". Most of the internet-drafts and RFCs start out life as prototype implementations, instead of writing specs first, experimental prototypes are developed, and the spec is extracted out of the winners.

People are acting like internet and web specs start life as a standards doc, it's iterated on until finalized, and then vendors start implementing it. That's very far from the truth, and I'd actually say harmful, as design by committee without real world experience often turns out terrible.

The difference is Chrome moves ahead anyway. This is why I'm calling it "standards-washing" -- if you take away the RFC it's no different from the browser wars era or Apple's proprietary CSS extensions for Safari back in the day.

How the standards process is supposed to work is something like this:

1. Someone creates a rough proposal. Discussion happens.

2. Someone creates a proof of concept toy implementation. Discussion happens.

3. Consensus is reached, a spec is written.

4. Other vendors implement the spec. Spec stabilizes with implementers' feedback.

How it now happens is like this:

1. Google writes feature proposal.

2. Google implements the feature behind a server-side flag.

3. Google creates training materials for developers to use the "upcoming" feature.

4. Optional: Google writes an actual spec.

5. Google either scraps the feature or makes it available without the flag.

Of course they "gather feedback" and "ask for input" but concerns from Mozilla routinely get ignored and implementation progresses regardless. It's entirely up to Google and they'll ship it if they like it. The "standard" just becomes a fig leaf.

This isn't entirely new, but the "standards-washing" gives it the appearance of being consensus-driven when in reality it's just more proprietary vendor extensions with marginally better documentation.

Google has an explicit agenda of what the future of the web should look like and they're taking Chrome down that route regardless of whether other vendors agree or not. There's nothing necessarily wrong with this, but consensus-driven or "open standards" this is not.

Contrast this with WHAT WG's promise in the early HTML 5 days: user concerns trump author concerns trump implementer concerns trump academic concerns. Google has decided that it is the sole authority on what users want and uses that to justify ignoring anyone else's concerns or objections.

This generally happens when committees are too far away from the actual development. It happens all the time at companies too with non-coding architects too. Standard setting bodies need to understand the pace of modern development, they spend way to long in the discussion phase. Once their is running code a lot of the discussion is basically over, and it's a choice of writing the spec to match what happens or browsers documenting the "quirks" with the standard.

That's not to say chrome isn't busing their market share. Even if there were more players though, it's a matter of Google gets MS/Apple/Mozilla to agree and nothing else really changes.

Right now Google does not feel the need to get any other browser vendors or really any other party besides Google to agree. They ship things that they don't even agree on internally! Their process has review points but actually acting on that feedback is totally up to the preferences of the person driving a given feature.

Do you have know of a writeup or blog post from someone involved in such actions that cites actual situations where this happened when google railroaded a new standard through?

Unfortunately, no. The closest to a writeup is this: https://webapicontroversy.com/

Chrome has running code, but generally skips the "rough consensus" step.

> That's very far from the truth, and I'd actually say harmful, as design by committee without real world experience often turns out terrible.

Google, however, actively ignores a lot of input, including full-on objections from other browser vendors (who do have real-world experience).

Designed by IE, sorry, Chrome, alone is just as bad.

Even the washing is so bad now, that it doesn't even matter:

- The spec we're discussing was "proposed" sometime in 2019. Here's a comment from WebKit on March 27 2020:

--- quote ---

I notice that this proposal still exists only in a random personal repo. Could it please be contributed to an appropriate standards or incubation group?

--- end quote ---

At sometime they did move it to the appropriate group

- WebHID that is now shipped in Chrome. They asked for Mozilla's position, and Mozilla couldn't even understand the proposal: https://github.com/mozilla/standards-positions/issues/459

And this keeps happening over and over and over and over again.

Their reaction when they are called out? When Mozilla and Safari flat-out refused to implement Constructible StyleSheets as they were spec'ed, Chrome still released them (because their own devs from lit-html relied on them), and said https://twitter.com/slightlylate/status/1220451799032877057

--- quote ---

We often lead, balancing risk/reward rather than demanding a particular point in an arbitrary process.

Leadership is rather the point of having an engine team, after all.

--- end quote ---

That is what they call "leadership".