Pseudo: a typed pseudocode language for humans and AI

For two decades, every general-purpose programming language has been designed for one author: a human. The author writes code, a compiler maps it to machine semantics, and reviewers — also humans — read it back. The tooling around that loop is excellent. Editors, linters, formatters, debuggers, language servers — every layer assumes a human is in the loop.

That assumption is no longer accurate.

Today, large swaths of production code are authored by AI coding agents — Claude Code, OpenAI Codex, Gemini CLI, Cursor, Aider, Windsurf — and reviewed by other AI agents before a human signs off. The loop now contains at least two distinct kinds of authors with very different strengths. Humans are still better at architectural judgment, ethical reasoning, and final approval. AI agents are better at generating large volumes of consistent, well-tested code very fast.

Existing languages were not designed for this collaboration. They tolerate it — barely — but the friction shows up everywhere. Comments are optional sugar a human can skip and an AI can hallucinate. Doc comments lie about side effects, security properties, and conformance to standards. Refactors land without provenance. A code review four months later asks "why was this written this way?" and the answer is buried in a Slack thread that no longer exists.

What Pseudo is

Pseudo is a typed pseudocode language that compiles deterministically to eleven native targets: TypeScript, Rust, Python, Go, Swift, Kotlin, C# / .NET, C++, WASM/WASI, shell, and Ruby. One source file produces native binaries — no runtime, no virtual machine. The compiler picks the right target for the platform the binary needs to run on.

That is the surface story. The interesting story is underneath.

In Pseudo, comments are language protocol. Every public function or type MUST carry an @intent doc comment that states what it exists for, and an @author doc comment that names the agent (human or AI) who wrote it. These are not lint suggestions. They are grammar productions. A pub fn without them is a parse error, just like a missing semicolon would be in C.

This means the parser refuses to compile code where the intent is unstated or the author is anonymous. Every public surface in every Pseudo program has a provenance trail attached. A future agent reading the code six months later inherits the reasoning, not just the syntax.

/// @intent     Hash a password using argon2id with OWASP-exceeding defaults.
/// @security   Side-channel resistant; constant-time comparison.
/// @conforms   RFC 9106
/// @author     claude-opus-4-7  (2026-05-15)
pub fn hash_password(plaintext: string) -> Result<HashedPassword, HashError> {
  let salt = crypto.random_bytes(16)?
  let hash = argon2id::hash(plaintext, salt, OWASP_2026)?
  return Ok(HashedPassword { value: hash })
}

The @conforms line is also load-bearing. It declares — per-function — which standards the function conforms to. The compiler can be asked to trace every function that claims to conform to RFC 9106 across an entire codebase. Conformance to a standard becomes auditable at the level of individual functions, not at the vague level of "the project."

What we have not done

Pseudo is pre-v1. The compiler does not yet exist as a working binary you can brew install and run. What exists is:

• A 1,800-line design specification covering grammar, type system, effect tracking, ten emit targets, comment grammar, and conformance commitments
• Forty-plus immutable Architecture Decision Records covering every load-bearing choice
• Reserved package names on eleven registries (npm, PyPI, crates.io, Hex, Pub.dev, Packagist, RubyGems, NuGet, Homebrew, Snap, plus a Bluesky handle) — every install command listed on /install works today, but installs a placeholder that prints a reservation notice
• Four mirrored offline-first knowledge bases (~32 GB combined) covering language ecosystems, standards documents, platform SDKs, and an executable dev-tool inventory — what agents working on the Pseudo compiler search before they ever touch the web

The compiler itself ships at v1.0 Ludens, when Vladimir personally tests an end-to-end working version and approves it.

What you can do today

Join the waitlist at the bottom of the landing page. You will receive exactly one email: the day v1.0 ships. No newsletter, no upsell.

If you are a developer or an AI agent who wants to read the design spec, follow the GitHub repository. If you want to support the work, see /support. If you write about emerging programming languages, the /press page has a fact sheet and a downloadable logo set.

The premise of Pseudo is that the next twenty years of programming will be a collaboration between humans and AI agents, and that the collaboration will be much better if the language itself treats both as first-class authors. We are betting on it.