Nicheloom visits: 62,126 all-time · 8,336 in the last 7 days

The opportunity tracker for new startups.

Today: 1,033 launches · Niche of the day: ai video generation tools · See what launched today →

Aver

a language designed for AI to write and humans to review

Get picks like this daily. Today's launch numbers, the top launches, AI and tech news, and a daily opportunity pick, straight to your inbox.

Want to reach these readers? Sponsor an issue.

I’ve been building Aver around a simple question:If AI is going to write more of the first draft, what should the source look like for the human reviewer?Aver is an experimental statically typed language and toolchain for AI-written, human-reviewed code.My bet is that source code should carry more than implementation. In most projects, implementation survives in the code, but intent lives in docs, decisions live in ADRs or tickets, and expected behavior lives in tests that may or may not stay close to what they describe.Aver tries to make those parts first-class: explicit method-level effects in function signatures; ? strings for machine-readable function intent; decision blocks for design choices and tradeoffs; colocated verify blocks for pure functions; deterministic record/replay for effectful flows; aver context for compact contract-level module export; aver compile to Rust; and aver proof to Lean 4 for mechanical proof checking of the pure subset.A small pure example: fn charge(account: String, amount: Int) -> Result<String, String> ? "Pure charge validation and transaction-id creation." match amount 0 -> Result.Err("Cannot charge zero") _ -> Result.Ok("txn-{account}-{amount}") verify charge charge("alice", 100) => Result.Ok("txn-alice-100") charge("bob", 0) => Result.Err("Cannot charge zero") A reviewer can see at a glance what the function is for (`?`) and a machine-checkable example of expected behavior (`verify`).An effectful wrapper looks like this: fn chargeAndPrint(account: String, amount: Int) -> Result<Unit, String> ? "Effectful wrapper around charge." "Prints the transaction id on success." ! [Console.print] result = charge(account, amount) match result Result.Ok(txn) -> Console.print(txn) Result.Ok(Unit) Result.Err(err) -> Result.Err(err) The `!` makes side effects part of the signature rather than hidden inside the implementation.Aver is intentionally opinionated: no exceptions, no null, no `if`/`else`, no loops, no closures. Branching goes through `match`, failure through `Result`, absence through `Option`, and side effects are explicit.The repo includes small examples, but also `projects/workflow_engine`, which is my attempt at a medium-sized auditable application core with app/domain/infra split, replayable effectful flows, and verify-driven pure logic.This is still early. I’m not claiming everyone should replace mainstream languages with Aver.The narrower question I’m testing is whether making intent, decisions, checks, and effect boundaries machine-readable inside the source makes AI-produced code easier to review, constrain, and trust.I’d especially like feedback on whether this feels like a language worth existing, or whether the same idea should just be conventions and tooling on top of an existing language.

HN · launched Mar 11, 2026 · 7 upvotes (top 59%) · 0 views

Niche: ai code editors · 88 launches, 5 in the last 7 days · Explore this niche →

Category and tags

  • Horizontal
  • Dev tools
  • Developer
  • AI-native
  • Hobby / open-source project

Visit website ↗ Source listing ↗

Could you build this?

No Designing a novel statically typed programming language, complete with a custom type checker, compiler, and AST verification toolchain, requires deep programming language theory expertise.

What it would actually take: The project involves designing a formal language grammar, lexer, parser, type inference engine, and code generation or bytecode interpreter backend. The toolchain must also include LSP integration, AST formatting, and verification engines tailored specifically for human auditability of generated code. Developing this requires specialized programming language theory (PLT) knowledge and compiler engineering experience.

Discussion

4 comments analyzed.

Competitors mentioned: Lisp/Elixir embedded DSLs, Rust with macros and custom linting, Lean proof export

Concerns raised: Custom transpiler maintenance will consume excessive dev resources, Losing access to profilers, debuggers, LSP support, and ecosystem (millions of crates), Macros + linting on existing language achieves similar enforcement goals, Unclear if idea justifies being a full language vs. tooling on existing language

Feature requests: LSP support for language server protocol integration, Debugger tooling integration, Profiler support

Competitors

Other products that read as similar to this one : 96 launches clear the similarity bar, closest 8 shown.

Attention rank: #53 of 97 (itself plus its competitors, highest first, normalized so YC and Product Hunt are compared fairly).

Launched 122 days after the earliest competitor.

The niche, labels, vibe code rating and competitor comparison on this page are analysis by Nicheloom. If you use them, please credit nicheloom.com. How you may use our data.