The intent language for AI-era software

Intent-Oriented Programming for the AI era.

IntentLang lets engineers define what software should do, why it matters, what must never happen, and how the result must be verified, before code is generated, changed, or shipped. Built by SkillsTech.

Join the Waitlist Read the Vision

View Examples →

The core promise: Write what your software should do. Let AI and the compiler help determine how to build it, verify it, and keep it understandable.

CreateInvoice.intent

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 intent CLI today.

Why IntentLang

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.

IntentLang starts with the what and why

IntentLang 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. IntentLang turns it into a reviewable, versionable, testable .intent 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.intent

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.intent

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

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

decision CanEnroll: Eligible [rule: adult]

$ intent test eligibility.intent

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.intent

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

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

Repository-aware

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

Human + AI collaboration

IntentLang 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 IntentLang is not

Clear about what we are not claiming.

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

Not an AI wrapper

IntentLang 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 IntentLang is structured, reviewable source, not a paragraph of instructions.

Not a no-code tool

IntentLang 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

IntentLang 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. IntentLang 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

IntentLang is the center of a larger system.

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

IntentLang

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.

SkillsTech IDE

Build it

The editor where you write, preview, compile, and verify intent, and connect it 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