TypeScript as a foundation for AI-assisted web development

In August 2025, TypeScript became the most-used language on GitHub by monthly contributors. That metric does not represent the entire industry, but it confirms a shift already visible across product teams: typed JavaScript is now part of the standard web development toolkit.

TypeScript covers the browser, React and Next.js, Node.js APIs, workers, and much of the surrounding tooling. A team can use one language from the frontend to the server. That convenience stops at runtime boundaries: a TypeScript interface does not validate JSON received from an API, a database, or an LLM.

A model generates plausible code. It may invent a property, miss a branch in a union, or call a function using an outdated signature. The compiler cannot tell whether a feature is useful, but it can compare the diff with the contracts that exist in the repository.

Code agents are generally familiar with common TypeScript APIs and patterns. That makes a first pass faster, but it does not guarantee a match with the installed version or local conventions. Diagnostics from the type checker bring the agent back to the codebase it is actually changing.

The type checker answers a narrow question: is this code compatible with the declared contracts? It cannot validate the product requirement, but its answer is fast and repeatable.

A good task for an agent has one clear goal. It states the expected behaviour, the relevant files, and the constraints that must remain intact. The first diff can then be checked with the repository’s own commands instead of relying on an abstract description of the project.

Errors from tsc --noEmit give the agent a concrete correction list. Once the automated checks pass, review can focus on everything they do not cover: intended behaviour, readability, operational risk, and whether the tests are meaningful.

import { tool } from 'ai'
import { z } from 'zod'

export const searchPlaces = tool({
    description: 'Search for places by name',
    inputSchema: z.object({
        query: z.string().min(2),
        limit: z.number().int().min(1).max(20),
    }),
    execute: async ({ query, limit }) => {
        return searchPlacesInDatabase({ query, limit })
    },
})

In this AI SDK example, the schema describes the tool input, validates the shape of the call, and provides the parameter types for execute. It does not decide whether the caller may run the search or which results they are allowed to see. Those rules still belong in server-side code.

Vercel’s AI SDK provides a common API for its supported providers, structured output, schema-validated tools, and UI primitives for React and Next.js. Available features and behaviour still depend on the selected provider and model.

TanStack AI provides a framework-agnostic core, typed tools, streaming, and adapters for multiple providers. The project is currently in beta, which should factor into architecture decisions and the expected maintenance cost.

1. 01

   Validate external data

   Zod, Valibot, or JSON Schema can reject a malformed call. Domain checks, such as access to a resource or a valid date range, still need explicit service logic.

2. 02

   Keep each tool contract narrow

   A tool with a few well-named parameters and a documented result is easier to call, test, and evolve than a generic function that exposes an entire service.

3. 03

   Review the resulting behaviour

   A diff can compile while choosing the wrong API, swallowing an error, or adding an unnecessary dependency. Review should cover those decisions, not just code shape.

The same schema can drive a tool call and its handler when both describe the exact same contract. API, domain, and persistence models should not be collapsed into one shape just to avoid a little mapping code.

With strict mode enabled, the compiler can catch a missing property, an unhandled undefined value or an incompatible response. It cannot tell whether a business rule is correct, whether a user is allowed to act or whether a query returns the right data. Those concerns still require runtime checks, focused tests and careful review.