惯性聚合 高效追踪和阅读你感兴趣的博客、新闻、科技资讯
阅读原文 在惯性聚合中打开

推荐订阅源

S
Schneier on Security
The Register - Security
The Register - Security
月光博客
月光博客
freeCodeCamp Programming Tutorials: Python, JavaScript, Git & More
OSCHINA 社区最新新闻
OSCHINA 社区最新新闻
The GitHub Blog
The GitHub Blog
博客园 - 司徒正美
罗磊的独立博客
U
Unit 42
S
SegmentFault 最新的问题
Y
Y Combinator Blog
博客园_首页
Hugging Face - Blog
Hugging Face - Blog
J
Java Code Geeks
Schneier on Security
Schneier on Security
Know Your Adversary
Know Your Adversary
C
Check Point Blog
Cyber Security Advisories - MS-ISAC
Cyber Security Advisories - MS-ISAC
Simon Willison's Weblog
Simon Willison's Weblog
V
Vulnerabilities – Threatpost
让小产品的独立变现更简单 - ezindie.com
让小产品的独立变现更简单 - ezindie.com
阮一峰的网络日志
阮一峰的网络日志
The Hacker News
The Hacker News
博客园 - 叶小钗
C
Cybersecurity and Infrastructure Security Agency CISA
Spread Privacy
Spread Privacy
L
LINUX DO - 热门话题
T
The Exploit Database - CXSecurity.com
P
Palo Alto Networks Blog
cs.CL updates on arXiv.org
cs.CL updates on arXiv.org
Latest news
Latest news
L
Lohrmann on Cybersecurity
A
About on SuperTechFans
L
LangChain Blog
Stack Overflow Blog
Stack Overflow Blog
S
Securelist
A
Arctic Wolf
D
Darknet – Hacking Tools, Hacker News & Cyber Security
T
Threatpost
Scott Helme
Scott Helme
博客园 - 聂微东
博客园 - 【当耐特】
T
Tenable Blog
I
Intezer
D
DataBreaches.Net
B
Blog RSS Feed
Security Latest
Security Latest
C
Cisco Blogs
T
Tor Project blog
N
Netflix TechBlog - Medium

DEV Community

Authentication Security Deep Dive: From Brute Force to Salted Hashing (With Java Examples) Why AI Systems Don’t Fail — They Drift Spilling beans for how i learn for exam😁"Reinforcement Learning Cheat Sheet" I Replaced Chrome with Safari for AI Browser Automation. Here's What Broke (and What Finally Worked) How Python Borrows Other People's Work The $40 Architecture: Processing 1 Billion API Requests with 99.99% Uptime Vibe Coding: A Workflow Guide (From Zero to SaaS) Most webhook security guides protect the wrong side. The scary part is delivery. Headless CMS for TanStack Start: Build a Blog with Cosmic EU Age Verification App "Hacked in 2 Minutes" — What Actually Happened Comfy Cloud’s delete function does not actually remove files Running AI Models on GPU Cloud Servers: A Beginner Guide Event-driven media intelligence with AWS Step Functions and Bedrock I scored 500 AI prompts across 8 quality dimensions — here's what broke How to Call Google Gemini API from Next.js (Free Tier, No Backend Needed) The Portal Protocol: Reclaiming Human Connection in the Age of AI How to Fix Your Team's Scattered Knowledge Problem With a Self-Hosted Forum Intro to tc Cloud Functors: A Graph-First Mental Model for the Modern Cloud Designing Multi-Tenant Backends With Both Ownership and Team Access I Built a Neumorphic CSS Library with 77+ Components — Here's What I Learned PostgreSQL Performance Optimization: Why Connection Pooling Is Critical at Scale Cómo construí un SaaS multi-rubro para gestionar expensas en Argentina con FastAPI + Vue 3 🚀 I Built an Ethical Hacking Scanner Tool – Open Source Project I Replaced /usage and /context in Claude Code With a Single Statusline A Pythonic Way to Handle Emails (IMAP/SMTP) with Auto-Discovery and AI-Ready Design I Collected 8.9 Million Polymarket Price Points — Here's What I Found About How Markets Really Move EcoTrack AI — Carbon Footprint Tracker & Dashboard Everyone's Using AI. No One Agrees How. 5 self-hosted ebook managers worth trying in 2026 Building Your First AI Agent with LangChain: From Chatbot to Autonomous Assistant Common SOC 2 Failures (Real World) Stop Vibe-Checking Your AI App: A Practical Guide to Evals How to Use SonarQube and SonarScanner Locally to Level Up Your Code Quality Your Next To-Do App Is Dead — I Replaced Mine with an OpenClaw AI Sign a Nostr event in 60 lines of Python using coincurve — no nostr-sdk, no nbxplorer, no rust toolchain ITGC Audit Explained Like You’re in Big 4 Patch Tuesday abril 2026: Microsoft parcha 163 vulnerabilidades y un zero-day en SharePoint Stop scraping everything: a better way to track competitor price changes Listing on MCPize + the Official MCP Registry while routing payments OUTSIDE the marketplace — how I kept 100% of my x402 revenue Building an AI-Powered Risk Intelligence System Using Serverless Architecture Why We Ripped Function Overloading Out of Our AI Toolchain Testing AI-Generated Code: How to Actually Know If It Works SaaS Churn Is Killing Your Business. Here Is What to Do About It (Without a Support Team) The Speed of AI Is No Longer Linear - And Self-Improving Models Are Why How to Implement RBAC for MCP Tools: A Practical Guide for Engineering Teams From Standard Quote to Persuasive Proposal: AI Automation for Arborists I built a CLI that scaffolds complete multi-tenant SaaS apps Axios CVE-2025–62718: The Silent SSRF Bug That Could Be Hiding in Your Node.js App Right Now The dashboard that ended our friendship Data Pipelines Explained Simply (and How to Build Them with Python) The Hidden Cost of AI Systems Nobody Talks About. undefined vs undeclared, and how typeof behaves Switching from file-based jobs to NATS/Kafka in Rust without changing code io_uring Adventures: Rust Servers That Love Syscalls Why Agentic AI is Killing the Traditional Database The POUR principles of web accessibility for developers and designers Quantum Neural Network 3D — A Deep Dive into Interactive WebGL Visualization How To Install Caveman In Codex On macOS And Windows Automation Pipeline Reliability: Why Your Workflow Breaks When Nobody Is Watching I Built an 'Open World' AI Coding Agent — It Works From ANY Folder From Freelancing to Product: A Tech Service Company's SaaS Transformation China's AI Giants: Adding Tencent Hunyuan & ByteDance Doubao to AI University (74 Providers) On the Vibe Coders and Their Lies clerk: Auto-Summarize Your Claude Code Sessions AI Weekly — 2026/04/10–04/17 | The Model Lockdown Is Here, but the Toolchain Is the Real Battleground AI 週報 — 2026/04/10–2026/04/17 模型封鎖潮來了,但工具鏈才是真戰場 Maybe this is how Open-Source apps are born... 🚀 Fine-Tune LLMs with LoRA and QLoRA: 2026 Guide tRPC v11 + Next.js App Router: End-to-End Type Safety Without the Boilerplate ShadCN UI in 2026: Why I Stopped Installing Component Libraries and Started Owning My Components SaaS Billing in React Server Components: Stripe + Supabase Without a Single `useEffect` Join our DEV Weekend Challenge — $1,000 in Prizes Across TEN winners! Submissions Due April 20 at 6:59 AM UTC. Implementing FSRS Spaced Repetition in Flutter + Supabase — Adding Memory Science to an AI Learning App "I Texted My Localhost From the Train — Claude Code Fixed the Bug Before I Got Home" I Built a Sales Prep AI and It Went Deeper Than Expected Design to Code #2: One JSON, Eleven Outputs Solving the 100M-Row Problem: A Summary Table Pattern for High-Volume Push Notification Logs Flutter Web With Wasm: What Actually Changes For Developers I Built 50 Royalty-Free Soundtracks for My Side Project in a Weekend Using AI Music Generation The Vibe Coding Security Checklist: 7 Things to Check Before You Ship Stop Letting Googlebot Guess Fix Your React App's SEO Right Desconstruindo o Streaming do LinkedIn: Como Criar um Engine de Extração de Vídeo de Alta Performance com HLS e FFmpeg (EDA Part-1) EDA (Exploratory Data Analysis) Explained With Real Life — Why Looking at Your Data Is the Most Important Step in Machine Learning Brand Relationship Management at Scale: Our 4-Touch Outreach System for 200+ Brands Why String.fromEnvironment() Might Return an Empty String in Dart JGuardrails 1.0.0 — Hardening Java LLM Apps Against Jailbreaks, Toxicity, and Prompt Injection Plan and Schedule a Full Week of Threads Content From One Claude Conversation Coding Cat Oran Ep3, Five Tables Changed Everything Updated: BFF Pattern I'm done watching freelancers get buried by 200 proposals. So I'm building the alternative. This is my first post BFS Algorithm in Java Step by Step Tutorial with Examples Tracking LLM Pricing Monthly: An Open Dataset for 22 AI Models How We Measure Content ROI on a Comparison Site: Revenue Attribution Without Perfect Data Introducing Nova AI Ops: The AI-Native Operating System for SRE Teams I built a free desktop video downloader for Windows — Grabbit How Talkie OCR Helps Vision-Impaired & Dyslexic Users Read the World Around Them VRCFaceTracking安装和iPhone面捕配置教程,有bug Even CrowdStrike Can't See Your Agents The Automation Gold Rush: What n8n Workflows and Claude Are Opening Up for Developers Right Now
Why We Built ll-lang, a Statically Typed Functional Language for LLMs
Roman Melnik · 2026-04-27 · via DEV Community

Why We Built a Statically Typed Functional Language for LLMs to Write

ll-lang is a language for one narrow, practical job: helping LLMs generate correct code faster by spending fewer tokens on syntax and getting compile-time feedback instead of runtime surprises.

The problem with "AI coding" is not that models cannot produce code. They clearly can. The problem is that most mainstream languages give them the wrong feedback loop.

When an LLM writes Python, TypeScript, or Java, two things usually happen at the same time.

First, the model burns a lot of context on syntax that does not carry much logic. Braces, semicolons, class wrappers, repeated keywords, interface boilerplate, and ceremony-heavy declarations all consume tokens. That matters when your real bottleneck is context budget.

Second, many important mistakes surface too late. A model can generate a file that looks plausible, passes a quick glance, and still fails only after execution. The signal arrives as a runtime error, a stack trace, or an application-side failure. By then, the model has already spent tokens on the wrong path.

That is an expensive loop:

write -> run -> inspect prose error -> regenerate -> run again

We built ll-lang to change that loop.

ll-lang is a statically typed functional language designed for LLM code generation. The design goal is narrow on purpose: make it easier for a model to write code that compiles, gets strong feedback quickly, and can still target normal downstream ecosystems like F#, TypeScript, Python, Java, and C#.

This is not a "replace every language" project. It is a tooling and authoring language for a specific constraint: an LLM agent writing code under token pressure.

The four design principles

The current README boils ll-lang down to four principles. They are worth unpacking because together they define the product.

1. Token-efficient syntax

We wanted a language that spends more tokens on logic and fewer on ceremony.

ll-lang keeps the syntax compact:

  • no braces
  • no semicolons
  • no fn, type, in, then, or with
  • only 15 keywords
  • declarations use an uppercase/lowercase convention instead of extra syntax

That matters more than it looks on paper. Every redundant token competes with actual reasoning. If an LLM has to generate an algebraic data type, a few helpers, and a pattern match, the difference between a compact representation and a verbose one compounds quickly.

The project README reports ll-lang as 8 to 17 percent more compact than F# on real code, and significantly more compact than TypeScript, Python, and Java on type-heavy definitions. That is not an aesthetic choice. It is directly about how much useful logic you can fit inside the same context window.

2. Static types with inference

A language for LLMs cannot force the model to annotate every line. That just reintroduces verbosity through another door.

So ll-lang uses Hindley-Milner type inference. You keep the guarantees of a static type system, but you only write annotations where they actually clarify boundaries. The compiler carries the rest.

This gives you a useful middle ground:

  • enough structure for compile-time guarantees
  • less annotation overhead for the model
  • fewer chances to drift between a declaration and an implementation

For an agent, that is a better authoring environment than either extreme. Fully dynamic code catches mistakes too late. Fully annotation-heavy code spends too much of the budget describing obvious facts.

3. Compiled equals works

This is the most important principle in the project.

ll-lang is designed so the compiler catches the classes of mistakes that LLMs make all the time:

  • type mismatches
  • unbound variables
  • non-exhaustive matches
  • tag violations
  • unit mismatches

In other words, the fast feedback signal is compile-time, not runtime.

That is a major shift for agent workflows. Instead of asking the model to mentally simulate a whole program and then parse a runtime failure, you can keep it on a tighter loop:

write -> check -> fix one precise error code -> continue

That is cheaper, faster, and much easier to automate.

4. LLM-readable errors

Even a strong type system is less useful if the diagnostics are written as long human prose that an agent has to scrape.

ll-lang errors are intentionally compact and machine-readable:

EXXX line:col ErrorKind details

Examples from the README include:

  • E001 12:5 TypeMismatch Str Str[UserId]
  • E003 15:1 NonExhaustiveMatch Shape missing:Empty
  • E004 20:9 UnitMismatch Float[m] Float[s]
  • E005 7:14 TagViolation Str[Email] Str[UserId]

This matters because an agent can route on the code first and the text second. It does not need a fragile natural-language parser to understand what went wrong.

A worked example: catching a real bug before runtime

Here is the kind of bug that shows up constantly in AI-generated code: a model mixes up raw strings, tagged identifiers, and measurements that should not compose.

In a dynamic language, that often survives until the application runs. In ll-lang, it gets rejected immediately.

module ResetFlow

tag UserId
tag Email
tag m
tag s

lookupEmail(id Str[UserId]) Str[Email] = "alice@example.com"[Email]
sendReset(to Str[Email]) = to

bad(rawId Str)(distance Float[m])(elapsed Float[s]) =
  email = lookupEmail rawId
  total = distance + elapsed
  sendReset rawId

Enter fullscreen mode Exit fullscreen mode

There are three distinct mistakes here:

  1. lookupEmail expects Str[UserId], but rawId is only Str.
  2. distance + elapsed tries to add meters and seconds.
  3. sendReset expects Str[Email], but receives a raw string.

Those are not edge cases. They are the exact kind of mistakes that happen when a model is juggling several concepts at once and loses one semantic detail at a callsite.

With ll-lang, the compiler catches them as first-order feedback. The error stream is not an afterthought. It is the product.

You get precise signals like:

  • E005 TagViolation for passing an untagged string where Str[UserId] or Str[Email] is required
  • E004 UnitMismatch for combining values that do not share compatible units

The fix is explicit and local:

module ResetFlow

tag UserId
tag Email
tag m
tag s

lookupEmail(id Str[UserId]) Str[Email] = "alice@example.com"[Email]
sendReset(to Str[Email]) = to
speed(distance Float[m])(elapsed Float[s]) = distance / elapsed

good(rawId Str)(distance Float[m])(elapsed Float[s]) =
  userId = rawId[UserId]
  email = lookupEmail userId
  rate = speed distance elapsed
  sendReset email

Enter fullscreen mode Exit fullscreen mode

That difference is exactly why "compiled equals works" is not just a slogan. It is the basis for a better agent loop.

If the model is going to make mistakes, which it will, we want those mistakes to collapse into compact compiler diagnostics instead of delayed runtime behavior.

Why this matters specifically for LLMs

Humans can often compensate for a weak signal. They read between the lines, trace a stack, remember a convention from elsewhere in the codebase, and infer what the system probably meant.

LLMs are different. They are much better when:

  • the syntax is regular
  • the error shape is stable
  • the repair target is local
  • the feedback arrives before execution

ll-lang leans into that reality instead of pretending models code the same way humans do.

A good LLM authoring language should make the happy path easy, but it should also make the failure path legible. That is where ll-lang spends most of its design budget.

Self-hosting is proof, not branding

A lot of language projects make ambitious claims early. We wanted something harder to fake.

ll-lang is self-hosting. The compiler pipeline is implemented in ll-lang, including the lexer, parser, elaborator, type inference, code generation, module system, and MCP server. The bootstrap fixpoint in the README is a strong statement of maturity:

compiler1.fs == compiler2.fs

That matters because it proves a few things at once:

  • the language can handle real compiler work, not just toy examples
  • the stdlib and module system are usable at meaningful scale
  • changes that break core semantics show up inside the language's own build loop

For DevRel, self-hosting also changes the story from "interesting experiment" to "working system with operational evidence."

The MCP layer turns the compiler into an agent tool

The language alone is only half the story. The other half is how an agent interacts with it.

ll-lang ships with an MCP server through lllc mcp. That means Claude Code, Cursor, Zed, and other MCP-capable clients can call compiler functionality as structured tools instead of shelling out and scraping terminal output.

The current README and user guide document 30 tools across:

  • compile and check flows
  • diagnostics and repair helpers
  • formatting and AST inspection
  • project graph and build operations
  • symbol navigation
  • dependency helpers
  • test helpers
  • FFI helpers
  • catalog and metadata lookups

That is important because it lets the model stay in a structured loop:

  1. write source
  2. call check_source or check_file
  3. inspect structured diagnostics
  4. call lookup_error or repair-oriented tools
  5. retry

This is a much cleaner architecture than "ask the agent to guess what a shell command meant."

Why not just use TypeScript or Python with better prompts?

Prompting helps, but it does not solve the underlying signal problem.

You can absolutely get useful code from mainstream languages. But for the specific case of LLM-authored logic, they still impose tradeoffs:

  • more syntax overhead
  • weaker compile-time guarantees in common workflows
  • noisier runtime failures
  • error messages optimized for people, not agents

ll-lang changes the default environment instead of asking the prompt to carry the entire burden.

Where ll-lang fits

ll-lang is a good fit when:

  • an LLM agent is generating typed business logic
  • compile-time correctness matters more than framework breadth
  • the same source may need to target multiple runtimes
  • token efficiency is a practical constraint

It is not trying to be the answer to every programming problem. It is a sharper tool for a narrower one.

That is usually a good sign.

Try it

Repo: https://github.com/Neftedollar/ll-lang
Landing page: https://neftedollar.com/ll-lang/

Bootstrap path from the current README:

git clone https://github.com/Neftedollar/ll-lang.git
cd ll-lang
LLLC_BOOTSTRAP_REINSTALL=1 ./tools/check-selfhost-ci.sh

Enter fullscreen mode Exit fullscreen mode

If you want to see the agent story directly, wire the MCP server into your client:

{
  "mcpServers": {
    "ll-lang": {
      "command": "lllc",
      "args": ["mcp"]
    }
  }
}

Enter fullscreen mode Exit fullscreen mode

The MCP server label is arbitrary. Some docs show lllc, others ll-lang. What matters is command: "lllc" with args: ["mcp"].

Then ask your editor or agent a simple question: "Does this compile?"

That is the core bet behind ll-lang. Give the model a language with less ceremony, stronger guarantees, and better diagnostics, and the quality of the coding loop improves materially.

For human-first languages, runtime is often where truth appears.

For agent-first workflows, that is too late.