is casting with `as` after a zod parse normal or am i doing types wrong Inference

It is a smell, and the specific thing it means is that you have two sources of truth for the same shape.

parse() already returns exactly the right type. Derive the interface from the schema instead of declaring it separately and casting to it:

const CreateUser = z.object({
  email: z.string().email(),
  age: z.number().int(),
})
type CreateUser = z.infer<typeof CreateUser>

Now there is one definition. Change the schema and every consumer updates. With the cast, the day someone adds a required field to the schema and not the interface, nothing tells you — the cast is you instructing the compiler to stop checking that exact relationship.

On the unreadable tooltip: that is a display problem, not a type problem. The ZodObject<...> wall is the schema's type; z.infer of it is a plain object type and hovers fine.

The other legitimate use is a library whose own types are wrong, where as unknown as X is the only way through. When you do it, leave a comment with a link to the upstream issue. Untracked casts become permanent, and in two years nobody will remember whether the library was fixed.

General rule that will serve you for years: every as is a small IOU written against future you.

Some are fine. as const is not really a cast. Narrowing an unknown you just validated is fine. as Foo on data you have not validated is how you get a runtime error that reads like the type system lied to you.

Yours is the middle case — harmless today because the schema and the interface happen to match, wrong the moment one of them changes. Which is why the advice above is to delete one of them rather than to write the cast more carefully.

One exception worth knowing: if you genuinely must keep a hand-written interface, because it is public API documentation or someone else imports it, do not cast between them. Assert they agree in both directions with two throwaway assignments in a test file, so drift becomes a compile error rather than a production surprise.

Cheap health check you can run right now:

grep -rc " as " src | awk -F: '{s+=$2} END {print s}'

Under about twenty in a real codebase and you are doing fine. Four hundred and you have a JavaScript codebase wearing a TypeScript hat, and the fix is not more casts, it is finding the two or three places generating them.

Doing types slightly wrong for six months is how literally everyone learns this language. The fact that the cast felt bad enough to ask about means your instincts are already ahead of your knowledge, which is the right way round.

as is "trust me" with a keyword.