isl-lang.org / blog / 2026-01-31

The Origins of ISL: From VibeCheck to the Compiler Contract

Intent Specification Language (ISL) is a formal system for expressing executable intent contracts that govern AI-generated code. ISL enables developers to specify behavioral properties, invariants, and conformance requirements that an AI system must satisfy. The language produces verifiable evidence of code behavior through semantic analysis, contract evaluation, and conformance testing — transforming subjective intent into objective proof.

Timeline

What ISL Is

  • A grammar and runtime for expressing intent contracts as first-class program artifacts. An intent block contains five core clauses: requires (input preconditions), ensures (output postconditions), produces (artifacts generated), evidence (proof collection directives), and verify (conformance predicates). The parser builds an AST where each clause becomes a semantic node.
  • An AST-based intermediate representation that bridges natural language intent and executable verification. The AST shape reflects the contract structure: intent nodes contain clause subtrees, each clause contains one or more quantified predicates (using forall for universal properties and exists for witness properties).
  • A semantic analyzer that maps contract clauses to program invariants and test predicates. The analyzer walks the AST, type-checks each requires and ensures clause against the target code's signature, and generates symbolic constraints for the verifier.
  • A verifier that evaluates quantified predicates over execution traces and produces cryptographically signed evidence of behavioral conformance. For forall clauses, the verifier checks that the predicate holds across all execution paths; for exists, it collects witness values that satisfy the predicate.
  • An evidence format suitable for audit trails, compliance reporting, and supply chain integrity. Evidence bundles are content-addressed artifacts that bind a code artifact, the intent contract, the execution trace, and the cryptographic proof into an immutable record.
  • A conformance suite enabling reproducible validation across AI systems and code generation pipelines. The suite defines four conformance levels: Level 1 (syntactic — contract parses), Level 2 (well-typed — clauses match code signature), Level 3 (verified — predicates evaluated true), Level 4 (evidence-attested — proof signed and timestamped).

Evidence Model

When an intent is executed against code, ISL produces a content-addressed evidence artifact. This artifact captures three things: the intent contract itself, the execution trace of the code (inputs, outputs, side effects), and the cryptographic proof that the trace satisfies the contract's clauses. A verifier then examines this evidence bundle to confirm behavioral conformance. Evidence bundles are immutable and timestamped, enabling supply chain integrity checks across distributed systems. They serve as the authoritative record of what code was intended to do and what it actually did.

The Genesis of the Design

ISL grew from VibeCheck's truthpack model — a system that gives AI coding agents verifiable ground truth documents. Rather than treating intent as implicit in prompts or code comments, ISL makes it explicit and parseable. This transforms intent from a narrative artifact into a contract. The language emerged from a practical problem: how do you verify that AI-generated code did what was asked? The answer requires a machine-readable spec of the intent itself. The parser was extracted from ShipGate's internal verifier and published as @isl-lang/parser on 2026-05-11 (62d62246). This enables external tooling to read and reason about intent contracts without requiring ShipGate's proprietary engine.

What ISL Is Not

  • Not a prompt template or instruction format for LLMs — ISL is language, not a jailbreak
  • Not a documentation convention or markup syntax — ISL parses to an AST, not comments
  • Not a linter rule pack or static analysis configuration — ISL specifies runtime behavior, not style
  • Not a domain-specific testing framework — ISL is implementation-agnostic and language-neutral
  • Not a type system extension — ISL operates at the contract layer, orthogonal to types
  • Not a natural language processing artifact — ISL requires formal parsing and semantic analysis

Why the Spec Is Open, the Engine Is Not

The ISL specification is published under MIT license as a community asset. The grammar, AST definitions, and conformance suite belong to the ecosystem. The verifier engine remains proprietary to ShipGate because it contains the core value: the ability to generate evidence of code behavior in production contexts. This mirrors the relationship between Linux (open specification) and enterprise distributions (implementation). The spec allows the community to build tooling; the engine provides assurance.

Getting Started

Built with ISL 🛡️