Vercel's konsistent Says Agent Coding Needs Structural Contracts

A lot of AI coding failures are not really coding failures.

The model can write valid TypeScript. The tests may even pass. Then the change still lands wrong because the repo expected a file pairing, an export shape, a naming contract, or a folder convention nobody bothered to encode clearly.

Vercel's decision to open-source konsistent matters because it treats that hidden structure as a first-class problem.

This is about structural repo rules, not prettier lint output

Butler has already spent plenty of time on the failure modes around AI coding systems, from why agents break on large repos to the cost surfaces around review agents to the expanding model shelf inside coding tools.

konsistent points at a different layer of the problem.

Vercel describes it as a TypeScript CLI linter for structural conventions that TypeScript and ESLint do not model. The examples are revealing: required companion files, required exports, implementation contracts, and folder-level expectations.

Those are exactly the kinds of rules that senior engineers often know implicitly and agents often guess badly.

Why this lands now

AI coding has made a lot of teams realize that their repos depend on unwritten law.

Humans absorb that law slowly through code review, hallway chat, and repetition. Agents do not.

If the architecture expects:

• every harness package to export certain symbols
• every folder with file X to also contain file Y
• every bridge implementation to expose a fixed protocol shape

then those expectations are real contracts whether or not the compiler enforces them.

konsistent is interesting because it says: fine, let's encode those contracts explicitly.

The agent angle is the real signal

Plenty of teams have built custom lint rules before.

The stronger signal here is that Vercel frames this tool around helping agents and humans implement features correctly, then points people to a skill that helps generate the configuration.

That means the workflow is no longer humans define rules for humans.

It is teams need repo conventions to become machine-readable because machine collaborators are now in the loop.

That is a more consequential shift.

Why TypeScript and ESLint were not enough for this job

TypeScript is good at types.

ESLint is good at many syntax and style constraints.

Neither automatically captures every architectural expectation a real codebase relies on.

The missing layer is often structural:

• what must exist together
• what a file category must export
• what folder patterns imply about companion modules
• what repo-specific bridge or harness contracts must be present

That is exactly where agent-generated changes tend to feel superficially fine and operationally wrong.

What teams should take from this

The lesson is bigger than one Vercel tool.

If your repo depends on important unwritten conventions, those conventions are now part of your AI-coding reliability surface.

A model cannot reliably obey rules your team never bothered to encode.

Even if you never use konsistent itself, the pattern matters:

• identify the structural expectations senior engineers enforce by instinct
• express them in machine-readable form
• check them before review rather than after drift lands

What this does not solve

It does not replace types.

It does not replace tests.

It does not replace code review.

It does not automatically create good architecture.

It does something narrower and very useful: it turns hidden repo rules into declared contracts.

For agent-heavy teams, that is often the difference between the code compiled and the code actually fit the system.

Related coverage

• the current model-shelf side of AI coding tools
• the review-agent cost lane Butler has tracked
• why AI coding agents fail on large repos

AI Disclosure

This article was researched and drafted with AI assistance, then reviewed and edited for clarity, accuracy, and editorial quality.