I just read PEP 695 and most of the things there seem like really nice improvements. There is one thing though that just feel wrong to me, and that is using the ** syntax for ParamSpec as in the example: ```python from typing import Callable def func[**P, R](cb: Callable[P, R], *args: P.args, **kwargs: P.kwargs) -> R: ... ``` The main reason is that in all other places in python ** always is used in combination kwargs or dicts. And ParamSpec isn't just kwargs, its args and kwargs. Meaning that ** has very different semantics in this pep then in other places in python and will be confusing. Another reason that I do not like ** for ParamSpec is that it might bite us in the future if there is a desire to continue building on PEP 692. That PEP introduces the possibilities to use a TypedDict to annotate kwargs as follows: ```python class Movie(TypedDict): name: str year: int def foo(**kwargs: **Movie) -> None: ... ``` So for me a natural extension of PEP 692 to would be to also make it possible to make foo generic in the above example using something as: ```python K = TypeVarDict("K") def foo(**kwargs: **K) -> None: ... ``` And once one has this it would only be natural to shorten this in the spirit of PEP 695 to something like ```python def foo[**K](**kwargs: **K) -> None: ... ``` Which is a syntax that is conflicting with the ParamSpec way of doing it. ```python def foo[**P](**kwargs: P.kwargs) -> None: ... ``` The most natural way for me to use Callable together with PEP 692 and PEP 695 would be ```python from typing import Callable def func[*A, **K, R](cb: Callable[A, K, R], *args: *A, **kwargs: **K) -> R: ... ``` which has an added benefit of providing a cleaner solution to the problem in PEP 612 then using ParamSpec.