NTNT

We're introducing NTNT (pronounced "Intent"), a programming language designed for AI-assisted software development.

Why Create a New Language?

A fair question. The world has plenty of programming languages.

We created NTNT to explore what a language designed for AI agents as the primary code authors might look like. Existing languages carry decades of assumptions. Syntax optimized for human typing speed. Idioms shaped by human memory limitations. Conventions that made sense before AI could generate thousands of lines of code in seconds.

By starting fresh, we can ask different questions:

• What if contracts were first-class citizens, not afterthoughts?
• What if requirements were executable, not just documentation?
• What if the language included a verification system from day one?
• What if tooling was designed for agents to introspect and understand code?

This exploration may prove beneficial or not. But having a language we can take in any direction gives us options that retrofitting existing languages cannot. NTNT is a research vehicle for understanding the future of human-AI collaborative development.

What Makes NTNT Agent-Friendly?

Several design decisions reduce the errors AI agents commonly make:

Hallucination-resistant syntax. In Python or JavaScript, agents often hallucinate methods like list.push() vs list.append() vs Array.push(). NTNT uses functions, not methods: len(x), push(arr, item). This reduces the search space for correct syntax. Routing functions like get(), post(), and listen() are global builtins, so there are no imports to guess.

Reduced cognitive load. NTNT strips away complex features that trip up agents:

• No borrow checker or lifetime annotations (the #1 cause of AI errors in Rust)
• No async/await function coloring to track
• Map-oriented data: shape data on the fly with map { "key": val } without defining structs for every intermediate value

Deterministic output. Response helpers like json() and html() handle serialization and headers automatically. Agents don't need to remember content-type headers or status codes.

Verifiable targets. In other languages, an agent writes code and hopes it matches the prompt. In NTNT, the intent file provides a machine-readable contract. The agent knows exactly what "success" looks like because requirements are executable tests, not fuzzy text.

Self-correction. If an agent forgets to implement a feature defined in the intent file, ntnt intent coverage reports exactly what's missing. The @implements annotation makes code searchable, so you can find where feature.user_login is implemented without parsing entire control flows.

Think of it as "prompt-friendly Rust." It has the rigor of a systems language to prevent runtime errors, the flexible data modeling of JavaScript to match how LLMs work with JSON, wrapped in a framework that verifies the agent understood the prompt.

What NTNT Includes

NTNT is not a toy or a DSL. It's a full-featured language:

• Language core: Functions, structs, traits, generics, union types, enums, pattern matching
• Design by contract: requires and ensures clauses built into the syntax
• Standard library: 15+ modules including HTTP server/client, PostgreSQL, JSON, CSV, file I/O, crypto, time with timezone support, and Go-style concurrency
• Web development: File-based routing, external templates with Mustache-style syntax, native hot-reload
• Single binary: No runtime dependencies, no package manager needed

Intent-Driven Development

The key innovation is Intent-Driven Development (IDD) powered by the Intent Assertion Language (IAL):

1. Write requirements in natural language .intent files
2. Define domain terms in a Glossary that IAL resolves to executable checks
3. Link code to requirements with @implements annotations
4. Run ntnt intent check to verify implementation matches intent

IAL bridges the gap between natural language and code. You write they see "Welcome" in your intent file, and IAL translates it to HTTP assertions. The agent writes code; the system verifies it actually does what the human asked for.

Can I Use IDD/IAL With Other Languages?

Yes. IDD and IAL are concepts, not NTNT-specific features.

The intent file format is language-agnostic. The glossary system, term rewriting, and primitive execution model can be implemented for any language. If you port IAL to Python, JavaScript, or Rust, you get the same benefits.

We built IAL into NTNT because we wanted to explore the concepts with full control over the language. But there's nothing stopping you from bringing these ideas to your language of choice.

Current State

NTNT is experimental. The language core, standard library, and IDD tooling work today. Still in progress: LSP server, package manager, and performance optimizations (currently a tree-walking interpreter).

Who Should Use NTNT?

NTNT is not production-ready. It's a great fit for:

• Exploring AI-assisted development workflows
• Experimenting with Intent-Driven Development
• Prototypes and proof-of-concepts
• Learning about contracts and formal specifications
• Contributing to language research

Get Started

Visit the Learn page for installation instructions and a complete walkthrough, or check out our GitHub repository for the source code.