Evidype

AI coding is easy on day 1. Evidype is for day 30.

Evidype is built around EvidyTS, a programming language and compiler designed specifically for AI-generated code. Humans optimize for brevity; AI agents do not. EvidyTS requires explicit intent, contracts, types, tests, and structure that human developers often avoid but AI can generate effortlessly. Evidype brings that compiler pressure into a VS Code workflow for TypeScript software that has to keep changing.

Install Free Alpha

Free Alpha: bring your own OpenAI or OpenRouter key. Prompts, code, and API keys do not go through Evidype servers by default.

Why mechanical pressure matters
Stack Overflow 2025 46% distrust AI-tool accuracy vs. 33% trust it; only about 3% highly trust AI output.
JetBrains 2025 Developer fears center on losing control while caring about code quality, reliability, context, and security.
arXiv 2026 302.6k verified AI-authored commits introduced 484,366 issues; 22.7% survived to the latest repository version.
33-second demo: adds 2-operator FM mode,
hits EvidyTS compile failure and repairs it.

AI can handle stricter engineering.

In higher-assurance software, extra rules are normal: explicit intent, restricted subsets, stronger contracts, and less room for ambiguous shortcuts. That instinct is already familiar in ecosystems such as SPARK/Ada and MISRA-style C/C++.

EvidyTS brings that tradeoff into AI-native development. The compiler makes the extra structure a requirement rather than a recommendation.

Read the blunt description of EvidyTS.

The language comes first

A language designed for the way AI produces code

Structure is no longer expensive

Humans reasonably resist ceremony when they must type every line. AI models can produce the extra structure reliability demands without boredom, fatigue, or resentment.

The compiler can demand more

If the main code producer can generate as much structure as needed, the language should require it: named specs, explicit types, contracts, companion scenarios, and browser-verified behavior.

EvidyTS is not an editor convention or a prompt template. It is a compiler that makes the discipline visible, enforceable, and repairable by the agent producing the code.

Without Evidype: ordinary AI coding

Day one

AI gets features on screen quickly. The early momentum is real.

Day seven

Files grow. Contracts blur. Tests stay thin. The agent starts patching around its own previous patches.

Day thirty

The project still needs AI speed, but now it also needs visible intent, mechanical checks, and repair loops before fragility becomes the default.

Evidype turns carefulness from a request into a mechanical requirement.

Where Evidype fits

Good fit

  • You are building a TypeScript app with AI.
  • You expect the project to keep growing.
  • You care about tests, structure, and future changes.
  • You want the agent to repair failures instead of leaving them for you.

Bad fit

  • You only want the fastest possible disposable demo.
  • You need a drop-in cleanup tool for an arbitrary existing codebase.
  • You do not want stricter rules.
  • You are not using TypeScript.

What Evidype is

A stricter VS Code AI workflow for TypeScript apps, modules, MVPs, internal tools, and controlled rewrites created inside Evidype from the start.

What Evidype is not

It is not a universal TypeScript compiler.

It is not a magic cleanup tool for any existing codebase.

It is not meant to ingest a random app and instantly make it maintainable.

Install

Install Free Alpha

Bring Evidype into VS Code, connect your own OpenAI or OpenRouter key, and start generated TypeScript under compiler and browser pressure from the first slice.

Install Free Alpha Read Documentation

Evidype runs as a local VS Code workflow by default. Your model provider connection stays between your editor and the provider you configure.

What Evidype forces before the project drifts

  • One primary concept per file so the model cannot hide logic everywhere.
  • Filename and export alignment so concepts stay mechanically findable.
  • Required @Spec on classes and methods so intent exists before implementation.
  • Explicit return types and stricter guardrails so ambiguity does not become runtime behavior.
  • Companion scenario tests so generated code has visible behavioral pressure.
  • Coverage debt so missing tests become visible before the project collapses.

Careless output should fail in places the agent can see, explain, and repair while the project is still young.