Every Nuxt job in 2026 is a TypeScript job, and the interview question is rarely "what is a generic". It is "type this API response so the wrong usage does not compile", "why does this as cast hide a bug", or "how does the type reach the template". TypeScript 7.0, the Go-based compiler, shipped on 8 July 2026 and made type checking roughly ten times faster without changing the language; knowing what it changed in configuration and what it means for Vue tooling is part of being current.

Know

• Types are a design tool. The point is to make illegal states unrepresentable: discriminated unions instead of boolean flags, unknown at boundaries instead of any, literal types instead of stringly-typed options. A senior candidate talks about types as the API contract of a module or component.
• Types are erased. Nothing checks at runtime; JSON from an API is unknown until a schema validates it. The runtime validation page is where "TypeScript makes it safe" is corrected.
• Inference does most of the work. Good TypeScript has few annotations: infer from values, from as const, from schemas (z.infer), from framework macros (defineProps<T>). Generics exist to preserve information through a function, not to decorate it.
• The framework layer has its own idioms: Vue's compiler macros and utility types, Nuxt's generated types under .nuxt/ (auto-imports, components, typed routes, typed $fetch from server routes, runtimeConfig augmentation), and project references that split app, server and shared type contexts.
• Configuration decides strictness and performance: strict (plus noUncheckedIndexedAccess), verbatimModuleSyntax, moduleResolution: 'bundler', isolatedModules, erasableSyntaxOnly for Node's native type stripping, and the TS 7 defaults and removals.
• TypeScript 7: a native port (Go), identical type-checking semantics to 6.0, 8–12× faster full builds, multithreaded checking (--checkers), new defaults (strict: true, module: esnext, types: [], rootDir: ./), removed legacy options (baseUrl, moduleResolution: node10, target: es5), and a language server rewrite. Vue template checking through the compiler API arrives with 7.1, so Vue projects still run vue-tsc on TypeScript 6 while the tooling catches up (verify).

How the pages fit

How it works

The interview task in miniature: an API client whose misuse does not compile.

import { z } from 'zod'

// The response contract exists once, as a schema; the type is derived.
export const productSchema = z.object({
  id: z.string(),
  name: z.string(),
  status: z.enum(['draft', 'published', 'archived']),
  price: z.object({ amount: z.number().int(), currency: z.string().length(3) }),
})
export type Product = z.infer<typeof productSchema>

// Illegal states are unrepresentable: a result is either ok with data or an error with a message, never both.
export type Result<T> = { ok: true, data: T } | { ok: false, error: { status: number, message: string } }

export async function getProduct(id: string): Promise<Result<Product>> {
  try {
    const raw: unknown = await $fetch(`/api/products/${id}`) // unknown until validated
    return { ok: true, data: productSchema.parse(raw) }
  }
  catch (e) {
    const status = typeof e === 'object' && e && 'status' in e ? Number((e as { status: unknown }).status) : 500
    return { ok: false, error: { status, message: e instanceof Error ? e.message : 'Unknown error' } }
  }
}

// Usage: the compiler forces the check before data is touched.
const result = await getProduct('1')
if (result.ok) console.log(result.data.name)
else console.error(result.error.status)

Exercise

Be able to say