The human control layer for AI-written software

ThunderLang was previously introduced as IntentLang.

Understand what your software is supposed to do, what it actually does, and whether you can trust it.

ThunderLang turns human goals into durable software contracts, scans existing code to recover meaning, maps the system, and connects implementation to verification and proof , so humans stay in control as AI writes more of the code. Built by SkillsTech.

Try the Playground Read the Docs

Explore Intent Atlas →View Examples →

Deterministic core. AI-assisted only when you enable it. No model required for the supported local analysis , the compiler, scanner, and proof run offline with no key.

CreateInvoice.thunder

1mission CreateInvoice
2
3goal
4  Generate an invoice from approved orders
5
6why
7  Customers need accurate invoices that are auditable and never duplicated.
8
9requires
10  Customer
11  ApprovedOrders
12
13input
14  customer: Customer
15  orders: List<Order>
16  idempotencyKey: IdempotencyKey
17
18output
19  invoice: Invoice
20
21guarantees
22  invoice.total is never negative
23  duplicate invoices are not created
24  every invoice is auditable
25
26never
27  create invoice for unapproved order
28  expose payment token in logs
29
30target
31  TypeScript
32  DotNet
33  OpenAPI
34  Tests
35  Markdown
36  Mermaid
37
38verify
39  unit tests
40  duplicate prevention test
41  audit trail test
42  security scan

Pre-1.0 syntax , and it compiles with the thunder CLI today.

Honest status

What works today, and what is still being built.

One manifest drives every status label on this site, so it can never claim more than the compiler actually does. Available means it ships in the compiler and is tested.

The intent CLI

Available

Install @skillstechtalk/thunderlang and run check, run, test, build, scan, and more.

Parser + Intent IR

Available

Deterministic parse into the canonical intent-graph-v1 / intent-ir-v1.

Executable decisions

Available

Run decision tables with a full first-hit trace, no code generated.

Lifecycles + temporal

Available

Walk a state machine and reject illegal transitions.

In-file tests

Available

case / scenario blocks run by intent test; the spec proves itself.

Intent Scanner + Fable

Available

Scan a project into explainable, risk-grouped findings. No AI, no key.

Comprehension level C0..C7

Available

Measure how well-understood each mission is, from Unknown to Governed.

TypeScript code generation

Available

intent gen emits a typed contract + real decision logic + honest TODO stubs.

Intent Atlas (CLI)

Available

Navigate many missions with intent atlas / index. No AI.

Proof artifacts

Available

intent build emits .thunder-proof.json: the source hash + every claim's status.

Editor + Language Server

Available

intent lsp gives diagnostics, completion, and hover over LSP.

Code to candidate intent

Experimental

intent lift infers a humble .thunder draft from TypeScript/Rust/Perl; always human-reviewed.

C# / Java code generation

Planned

The TypeScript adapter's shape extends to more targets next.

Visual Intent Atlas

Experimental

The interactive map lives in Skills Tech Studio; the CLI + graph are available today.

Intent Engine (AI assist)

Planned

Optional, traced, human-approved prompt-to-intent and generation. Deterministic core needs no model.

See the full roadmap →

500+

compiler tests, all passing

canonical Intent Graph node types

60+

explainable diagnostics

worked examples

export formats (DMN, BPMN, OpenAPI, ...)

v0.1.1

pre-1.0, deterministic, no AI required

Developer preview. Run it now in the Playground. The thunder CLI ships as @skillstechtalk/thunderlang soon.

Define. Scan. Prove.

One statement of intent, checked and proven , not just generated.

Write what must be true, let the scanner find the risk, and get proof of what holds and what does not. Deterministic, no AI required.

1 , Define

guarantee duplicate invoices
  are never created

never expose payment token

State the guarantees and the prohibitions in durable, reviewable intent.

2 , Scan

Risk: the retry path has no
idempotency verification

Risk: guarantee has nothing
proving it (drift hides here)

The Intent Scanner surfaces explainable risks, grouped by theme. No AI, no key.

3 , Prove

PASS   duplicate prevention
PASS   audit trail
BLOCK  payment token found
       in event payload

A proof artifact records the status of every claim , earned trust, not assumed.

Run it in the Playground →

Intent Truth

Four truths about the same software , and where they disagree is where risk lives.

A feature can pass every test and still fail its purpose. ThunderLang keeps these four truths separate so you can compare them honestly, rather than assuming technical success means success.

Intended Truth

Available

What humans approved: goals, guarantees, prohibitions, and how each must be verified. This is the intent you write.

Implemented Truth

Experimental

What the code actually does, recovered from source with intent lift and surfaced by the Intent Scanner.

Observed Truth

Planned

What actually happens at runtime , traces, metrics, errors. Connected through OpenThunder and runtime evidence.

Outcome Truth

Experimental

Whether it achieved its purpose. Outcome contracts bind a target and guardrails; real measurement needs product analytics.

Intended Truth is available today. Implemented, Observed, and Outcome Truth arrive as the scanner, runtime evidence, and the wider ecosystem connect , honestly labeled, never assumed.

Why ThunderLang

Software is being written faster than it can be understood.

Intent-Oriented Programming puts the meaning of software first, so engineers and AI can move quickly without losing the thread of what the code is supposed to do.

AI writes faster than we can review

AI can generate code faster than humans can read, review, and trust it. Reviewing output line by line does not scale.

Traditional languages start with the how

Most languages ask you to commit to implementation first. The original intent is scattered across code, tickets, and memory.

ThunderLang starts with the what and why

ThunderLang focuses on what the software should do, why it exists, which constraints matter, and how it should be verified.

Engineers stay in control

The goal is not to replace engineers. It is to help them express, verify, and own software far more clearly.

Prompt is temporary. Intent is durable.

A prompt is a conversation. Intent is a commitment.

A prompt is useful, but it is not a contract, it is not cleanly versioned, and it is not automatically verifiable. ThunderLang turns it into a reviewable, versionable, testable .thunder file.

The prompt

“Build a secure invoice creation flow that prevents duplicates, audits every invoice, and never logs payment tokens.”

Useful, but temporary. It becomes intent on the right.

The intent

CreateInvoice.thunder

1mission CreateInvoice
2
3goal
4  Generate an invoice from approved orders
5
6why
7  Customers need accurate invoices that are auditable and never duplicated.
8
9requires
10  Customer
11  ApprovedOrders
12
13input
14  customer: Customer
15  orders: List<Order>
16  idempotencyKey: IdempotencyKey
17
18output
19  invoice: Invoice
20
21guarantees
22  invoice.total is never negative
23  duplicate invoices are not created
24  every invoice is auditable
25
26never
27  create invoice for unapproved order
28  expose payment token in logs
29
30target
31  TypeScript
32  DotNet
33  OpenAPI
34  Tests
35  Markdown
36  Mermaid
37
38verify
39  unit tests
40  duplicate prevention test
41  audit trail test
42  security scan

Core philosophy

Prompt → Intent → Contract → Plan → Implementation → Verification → Proof

Prompt is how the conversation starts. Intent is what the team commits to. Code is how the system fulfills it. Proof is how trust is earned. Every stage is inspectable, and nothing is hidden from the engineer who owns it.

Prompt

How the conversation starts. Useful, but temporary.

Intent

What the team commits to. Durable and reviewable.

Contract

The guarantees and constraints that must hold.

Plan

A deterministic implementation plan, before any code.

Implementation

Code in your target language, human or AI authored.

Verification

Types, tests, and checks that the contract holds.

Proof

Durable evidence that intent and reality agree.

Beyond prompt engineering

Intent you can run. No code. No AI.

A decision is not a description of behavior, it is the behavior. Give it inputs and it decides, first matching rule wins, deterministically, before any implementation exists. Tests live in the same file and prove it.

eligibility.thunder

1decision CanEnroll
2  inputs
3    age
4    score
5  rule adult
6    when age >= 18 and score >= 70
7    return Eligible
8  default
9    return NotEligible
10
11test CanEnroll
12  case adult
13    given age 20, score 90
14    expect Eligible
15  case minor
16    given age 10
17    expect NotEligible

$ thunder run eligibility.thunder --inputs '{"age":20,"score":90}'

decision CanEnroll: Eligible [rule: adult]

$ thunder test eligibility.thunder

PASS CanEnroll / adult

PASS CanEnroll / minor

2/2 passed

Deterministic: the same intent and inputs always decide the same way, with a full trace, no model in the loop. Run it yourself in the playground.

Example syntax

Describe the mission. Let tooling handle the rest.

A Mission states a goal, what it requires, the guarantees that must hold, and the languages it should target. It reads top-to-bottom like structured pseudocode.

TypeScriptPython.NETJavaGoRust

This is pre-1.0 syntax. It compiles today, but names, keywords, and structure can still change before 1.0.

View Examples Read the Docs

CreateInvoice.thunder

1mission CreateInvoice
2
3goal
4  Generate an invoice from approved orders
5
6why
7  Customers need accurate invoices that are auditable and never duplicated.
8
9requires
10  Customer
11  ApprovedOrders
12
13input
14  customer: Customer
15  orders: List<Order>
16  idempotencyKey: IdempotencyKey
17
18output
19  invoice: Invoice
20
21guarantees
22  invoice.total is never negative
23  duplicate invoices are not created
24  every invoice is auditable
25
26never
27  create invoice for unapproved order
28  expose payment token in logs
29
30target
31  TypeScript
32  DotNet
33  OpenAPI
34  Tests
35  Markdown
36  Mermaid
37
38verify
39  unit tests
40  duplicate prevention test
41  audit trail test
42  security scan

Language principles

Ten commitments that shape the language.

These principles are the north star for every design decision in Intent.

Intent-first

Code begins with what the software should accomplish, not with the implementation.

Reads like structured pseudocode

A senior engineer, architect, product manager, or AI agent should understand the file on first read.

Contracts by default

Every mission can declare its requirements, guarantees, constraints, and forbidden behavior.

AI-assisted but deterministic

AI may help generate implementation, tests, docs, and explanations, but the build stays reproducible.

Multi-target

One mission can target TypeScript, Python, .NET, Java, Go, or Rust through adapters.

Verification-first

A mission is not complete because code exists. It is complete when its guarantees are verified.

Architecture-aware

ThunderLang understands services, APIs, events, databases, dependencies, ownership, and boundaries.

Repository-aware

ThunderLang maps missions to real repo files, services, tests, docs, and ownership.

Human + AI collaboration

ThunderLang gives humans a clear way to express judgment and gives AI a structured way to help.

Proof-producing

Every completed mission can produce proof: tests, reports, docs, an implementation trace, and a verification summary.

What ThunderLang is not

Clear about what we are not claiming.

Being honest about the boundaries is part of being a serious language project. ThunderLang sits above paradigms and targets your languages; it does not replace them.

Not an AI wrapper

ThunderLang is a language with its own model of intent, contracts, and verification, not a thin shell over a chat API.

Not a prompt format only

Prompts are one way to draft intent, but ThunderLang is structured, reviewable source, not a paragraph of instructions.

Not a no-code tool

ThunderLang is for engineers. It makes engineering intent explicit; it does not hide the system from the people who own it.

Not a replacement for every language

ThunderLang sits above Python, TypeScript, .NET, Java, Go, and Rust as an intent and verification layer. It targets them; it does not erase them.

Not magic

There is no hidden trick. ThunderLang makes goals and guarantees explicit so tools can help you keep them.

Not production-ready yet

Not until the compiler, runtime, tests, and verification engine prove it. And it makes no claim to outperform the languages it targets today.

SkillsTech ecosystem

ThunderLang is the center of a larger system.

Proof is the through-line. ThunderLang defines what software should do, and each product proves a different thing about the same mission.

ThunderLang

Define what software should do

The intent-oriented language at the center: a clear, structured statement of goals, constraints, and guarantees.

OpenThunder

Proves the repo matches the intent

Reads intent, compares it to the real repo, and detects drift: unverified guarantees, violated rules, and ownership gaps.

Repo Mastery

Proves the human understands the mission

Turns missions into learning paths, quizzes, and reality checks so engineers truly understand the code they own.

SkillsTech Talk

Explain and defend it

Turns missions into drills for articulating and defending the design decisions behind the software you own.

SkillsTech Certified

Proves the learner understands the method

A path to demonstrate real, verifiable command of Intent-Oriented Programming and the intent behind a codebase.

Skills Tech Studio

Build it

The desktop environment where every role writes, previews, compiles, verifies, and traces intent, connected to real repo files.

The artifact exists, the implementation still matches it, the engineer who owns it understands it, and the practitioner has proven the method. That is how trust is earned in AI-era software: not by trusting the code, but by proving the intent behind it.

Early access

Help shape the first Intent-Oriented language.

Join the waitlist to follow the language as it takes shape and get early access to docs, examples, and the playground.

Join the Waitlist See the Roadmap