NL++

Pseudocode for AI coding agents.
Sketch structure and intent. The LLM fills it in.

// sketch your architecture, let the agent fill it in
service OrderService {
  uses PaymentGateway
  method auto place_order(Order order) {
    uses PaymentGateway.charge
    /?
      Must be idempotent. Kick off fulfilment on success.
    ?/
  }
}

Read the spec ↗ View on GitHub

What it is

NL++ is a minimal pseudocode language for expressing software architecture and implementation intent to AI coding agents. It is not compiled or executed — its output is a structured prompt: resolved pseudocode with an appended glossary of keyword definitions, ready to be passed to a coding agent.

The language enforces just enough structure to be toolable — syntax highlighting, autocomplete, symbol resolution, and import inlining — while leaving semantic interpretation deliberately open. The LLM is the compiler.

How it works

01 Sketch

Write .nlpp files describing your architecture: services, methods, fields, and prose notes for the LLM. Use ??? to mark areas left open for the agent to expand.

02 Resolve

The language server inlines imports, resolves symbols, and builds a flat annotated prompt from your file graph — author comments stripped, keyword definitions appended.

03 Generate

Hand the resolved prompt to any coding agent. The LLM is the compiler — it turns your structure and intent into working code.

Examples

NL++ stays out of your way: declare structure with a handful of keywords, lean on ??? and prose blocks /? … ?/ for anything you'd rather describe than spell out.

Types, references & templates

// & marks a reference; [ ] parameterizes a type
enum Role {
  field admin
  field member
  field guest
}

interface Store {
  method &Session login(User user, string token)
  method Array[User] members(Role role)
}

class Team {
  field auto id
  field Map[string, Role] roster
  field Array[User, 32] seats
}

Vocabulary, imports & intent

import "./payments.nlpp"

// coin a first-class term for this design
define aggregate "A DDD aggregate root — owns its invariants."

aggregate Cart {
  uses PaymentGateway
  method auto checkout(User user) {
    /?
      Validate stock, then charge via PaymentGateway.
      Must be idempotent on the order id.
    ?/
  }
  ??? add discount rules
}

Full syntax in the spec ↗

Ways to use it

NL++ is just a resolved prompt at the end of the day, so you can drive it however you work — a terminal, your editor, or an agent that owns the whole loop.

Direct compiler

Available

Run the compiler from the terminal. It inlines imports and prints the finished prompt to stdout — pipe it into any agent, your clipboard, or a file.

# today (pre-release) — run it from the repo
git clone https://github.com/stur86/nlpp-ts-server
cd nlpp-ts-server && bun install
bun run src/cli.ts path/to/app.nlpp

# once published to npm
npx nlpp-compile app.nlpp   # or: bunx nlpp-compile app.nlpp

Pipe straight into your flow: … | pbcopy or > prompt.txt.
Regenerate prompts in CI so they never drift from the source.
Best for scripts, pipelines, editor-agnostic setups, or to use with your own custom agents.

nlpp-ts-server ↗

VS Code extension

Pending

Sketch .nlpp with live highlighting, autocomplete, hover docs, and go-to-definition. A built-in nlpp_compile MCP tool lets an in-editor agent compile and build in one step.

# not yet on the Marketplace — install from source
git clone https://github.com/stur86/nlpp-vscode
cd nlpp-vscode && bun install
bun run install-extension

Best when NL++ is part of your day-to-day editing.
The editor keeps your file graph resolved as you type.
Marketplace listing is on the way.

nlpp-vscode ↗

Claude Code plugin

Available

Install the NL++ plugin into Claude Code. It adds a skill that compiles a .nlpp entry file and implements the described software from it — the whole sketch → code loop, inside the agent.

claude plugin marketplace add stur86/nlpp-claude
claude plugin install nlpp-claude@nlpp
# then point Claude at an entry file and ask it to build

Best when you want the agent to own compilation and implementation end to end.
Shells out to the same compiler — one source of truth for the prompt.

Ecosystem

LSP + compiler — TypeScript