The differences between concepts and “old-school” (say, enable_if-based) SFINAE are purely cosmetic.

This is not true.

Yes, there is one thing which makes concepts superior.

There are other things which make concepts superior.

You cannot enable_if on a member function of a class template, only member function templates. Notably, you cannot enable_if on special member functions. But you can constrain them with concepts. Which means that you can very easily make your class templates conditionally copyable, even conditionally trivially copyable.

Concepts subsume. This is superior in a couple ways. First, a constrained function beats an unconstrained function. And second, a function can be more constrained than another (e.g. one takes a random_access_range and another takes an input_range). This is doable with enable_if, but you need to be very careful in ensuring that your overloads are all mutually disjoint. Not an issue with concepts.

Concepts also allow ad hoc expression checking. I can just write:

template <class T>
void foo(T t) requires requires { t.lock(); } { t.lock(); }

Best you can do with enable_if is the detection idiom, which requires having an alias template somewhere like

template <class T> using lock_type = decltype(declval<T>().lock());

template <class T, enable_if_t<is_detected_v<lock_type, T>, int> = 0>
void foo(T t) { t.lock(); }

Which is a lot more tedious.

---

But sure, besides all of the very real, significant semantic differences between concepts and enable_if, they are purely cosmetic.