I recently encountered usefulness in preserving type variable relationship as mentioned in this issue, https://github.com/microsoft/pyright/issues/3119. An example with current type guard both mypy and pyright produce an error on this code, from typing_extensions import TypeGuard def is_int(x: object) -> TypeGuard[int] return isinstance(x, int) def f(x: T) -> T: if is_int(x): return x # type here is int not int* so an error is produced return x While error is correct it would be nice for typeguards to preserve typevar relationship. But honestly right now I only have 2/3 times this issue appears in my current codebase of 100k lines (mostly typed). So it's fairly small need. Negative part of logic I remember thinking interesting, but then I reviewed my codebase for usages of typeguards and false positives due to lack of negative narrowing and found only 1/2 cases of it. On assertion type guards I don't understand what practical difference between an existing typeguard with an assertion and a typeguard with NoReturn as negative argument. I sometimes have code like, def is_type_list(...) -> TypeGuard[...]: ... def foo(config: object): assert is_type_list(config, int) and that looks to work. It does remove assert statement in foo, but if that's difference it feels quite minor. My overall sentiment is weakly positive, but I think biggest reason these issues are infrequently felt is a lot of libraries type hints/typeshed does not use TypeGuard enough to notice these interactions. Maybe as time passes if typeguard becomes more common in typeshed these issues will pop back up.