MentorMind Varro eduKG
Start

Start here

Follow the learner path before using the reference pages.

Varro is easiest when read in causal order: authoritative sources first, then the checked VSL contract, then Helios, then live systems, agents, and surfaces.

Start the learner path Use the glossary

Course contract

What this public course promises

Title
Varro eduKG
Audience
Deep technical software engineer learning Varro/VSL from first principles.
Prerequisites
Comfort reading code-shaped specifications; no prior Varro knowledge is assumed.
Duration
3 hours
Module sequence
The five verbs; The type model; Actions & workflows; The maturity ladder; Crystallisation phases; Surfaces & lowering; Governance & principles
Assessment model
Each module has a scored retrieval quiz, reveal-gated checks, common traps, and hands-on author-and-check exercises.
Completion standard
Pass the module checks and complete the capstone author-and-validate task against varro check vsl.
Version
1.0.0
Review status
Technically gated; pedagogical acceptance review in progress. See the public E4 rubric.

Outcomes

What each module makes observable

Choose the correct Varro verb for a read, render, validation, execution, or creation task.
Author and explain the checked type-model constructs that make invalid data shape fail.
Separate actions, queries, and workflows, then explain how ordered behaviour is governed.
Place a specification on the draft to hardened ladder and state what each rung proves or does not prove.
Explain how prose becomes formal VSL, generated artifacts, and proof-bearing Crystal outputs.
Describe how compile targets, routes, views, agents, context, and runtime expose checked contracts.
Apply source authority and preview-by-default to judge whether a Varro surface is safe to act on.

A contract that can fail

The checker catches real structural defects.

The pinned hero spec intentionally fails validation. The public page quotes the real Varro diagnostic, and the HERO gate re-runs the checker so stale or invented diagnostics fail the build.

system `mentormind.demo.broken` is missing `context root = ...`
type `Booking` in system `mentormind.demo.broken` field `booking_id` references unknown type `UnknownType`

Why this course exists

Varro makes a specification something that can fail.

Most software is specified in prose. Prose is expressive — and weightless: when a prose requirement is violated, nothing fails except, eventually, a human noticing. As systems are increasingly built by autonomous agents, that weakness turns dangerous — an agent satisfies the visible words of a specification while missing its intent.

Varro is part of the answer. VSL — the Varro Specification Language — turns the checkable structure of a specification (systems, types, closed enums, actions, workflows) into typed contracts, and varro check fails when that structure is violated. So the structural part becomes load-bearing: a violation fails against a real artifact, not just human attention. The prose, diagrams, and worked examples stay — VSL (with the Helios type system and Lean proofs) makes what can be checked fail when it is wrong; it does not replace the rest.

The principles

  • Make the checkable part load-bearing — not everything. VSL turns a spec's describable structure into typed contracts the checker enforces; the Helios type system and Lean proofs (the Crystal phase) harden it further. It does not replace prose, diagrams, or worked examples — those carry intent, rationale, and what resists formalisation.
  • Preview-by-default. Governed actions describe what they will do before they commit; the safe path is the default.
  • The authority stack. Sources first, Varro as the window, callers last — Varro is a governed view, never the source of truth.
  • Two grammars, kept separate. VSL describes systems (types, enums, workflows); the five verbs (ask, show, check, run, create) are how you interact with them.
  • Specifications harden in phases. A spec crystallises from prose (Plasma) to VSL (Gas) to Rust (Solid) to Lean-proved (Crystal) — prove only what can honestly be proved.

How the pieces fit

You describe a system and its type model (types, fields, closed enums). You give it behaviour (actions, workflows, queries). You interact through the five verbs. A spec advances along the maturity ladder and the crystallisation phases as it hardens. Surfaces (routes, views, agents) and the authority stack govern how it is exposed.

How to read this

New to Varro? Use the learner path first. It introduces source authority, VSL, Helios, live systems, and agents in the order a new reader needs. Then use the modules below as reference pages for worked examples, hands-on exercises checked by varro check, common traps, self-checks, and scored quizzes. The written pages target the Deep technical software engineer; agents consume the same material as a citation-grounded pack.

Reference modules

  1. 01 The five verbs — The closed command grammar: ask, show, check, run, create.
  2. 02 The type model — Systems, types, fields and closed enums.
  3. 03 Actions & workflows — Governed actions, ordered workflows, and reads.
  4. 04 The maturity ladder — draft -> checked -> bound -> hardened.
  5. 05 Crystallisation phases — Plasma -> Gas -> Liquid -> Solid -> Crystal.
  6. 06 Surfaces & lowering — compile, route, view, agent, context, runtime.
  7. 07 Governance & principles — Authority stack, preview-by-default, VSL, Varro.
  8. 08 Learning path — the prerequisite-ordered sequence through all 31 concepts.

Grounded in the Varro bootstrap glossary, the specification-crystallisation architecture, and the load-bearing-specifications thesis.