Hacker News Reader

Comment by gnanagurusrgs | Hacker News Reader

Creator here. This started as a dumb question while using Claude Code: "Why is Claude writing TypeScript I'm supposed to read?"

40% of code is now machine-written. That number's only going up. So I spent some weekends asking: what would an intermediate language look like if we stopped pretending humans are the authors?

NERD is the experiment.

Bootstrap compiler works, compiles to native via LLVM. It's rough, probably wrong in interesting ways, but it runs. Could be a terrible idea. Could be onto something. Either way, it was a fun rabbit hole.

Contributors welcome if this seems interesting to you - early stage, lots to figure out: https://github.com/Nerd-Lang/nerd-lang-core

Happy to chat about design decisions or argue about whether this makes any sense at all.

View on HN

> 40% of code is now machine-written

How did you arrive at that number?

Ran a simple test with the examples you find in the project. Will publish those benchmarks.. actually that makes me think, I should probably do a public test suite showing the results. :)

Ok, now I'm even more confused. 40% of what code is machine written?

Check this out: https://www.nerd-lang.org/recipes

That does not answer the question

The same way LLMs arrive at things? :)

Update:

On New Year's Eve I announced NERD - a language built for LLMs, not for human authorship. The response was unexpectedly overwhelming. Questions, excitement, discussions, roasting - all of it.

But one question struck me: "What use case is this language built for?"

Fair. Instead of a general-purpose language covering all features - some of which may not even be relevant because we're not building apps the old way anymore - I picked one: agent-first.

What this means - you can now run an agent in NERD with one line of code:

-- Nerd code llm claude "What is Cloudflare Workers?"

No imports. No boilerplate. No framework.

The insight from working with agents and MCP: tools are absorbing integration complexity. Auth, retries, rate limiting - all moving into tool providers. What's left for agents? Orchestration.

And orchestration doesn't need much: → LLM calls → Tool calls → Control flow → That's it.

Every language today - Python, TypeScript, Java - was built for something else, then repurposed for agents. NERD starts from agents.

Fully story here: https://www.nerd-lang.org/agent-first

I love the idea! I’m glad you did this.

What about something like clojure? It’s already pretty succinct and Claude knows it quite well.

Plus there are heavily documented libraries that it knows how to use and are in its training data.

Thats an excellent point, it was a hard choice for me to say no translations at this point. But definitely can think about this as a design choice at the byte code / compiler level as this evolves.

Do jump in to contribute, these are amazing thoughts.

> "Why is Claude writing TypeScript I'm supposed to read?" 40% of code is now machine-written. That number's only going up.

How much of the code is read by humans, though? I think using languages that LLMs work well with, like TS or Python, makes a lot of sense but the chosen language still needs to be readable by humans.

Why do people keep saying LLMs work well with high level scripting languages?

I've never had a good result. Just tons of silent bugs that are obvious those experienced with Python, JS/TS, etc. and subtle to everyone else.

Perhaps they are being more successful in their use of llm's than you are?

Yes "success" as they understand it, and they are always so smug while refusing to show or even discuss the code the LLM produced.

A poor craftsman may blame his tools, but some tools really are the wrong ones for the job.

I keep having this nagging suspicion that the biggest AI boosters just aren’t very good programmers. Maybe they cannot see all the subtle bugs. I’m not an amazing coder but I frequently have “wait, stop!” moments when generating code with an LLM.

Interesting. I've had a similar idea for some time, but originating from near opposite intent. I'd like to see LLMs generate natural language that can be executed by machine, but remains very readable by someone who's never learned a programming language.

Yes, this opens up programming access to many :)

Now that we know code is a killer app for LLMs, why would we keep tokenizing code as if it were human language? I would expect someone's fixing their tokenizer to densify existing code patterns for upcoming training runs (and make them more semantically aligned).

If humans are supposed to be reviewing code why does reducing reviewability make any sense?

Your big idea seems to be changing the tech so that developers have an excuse to be even less responsible than they already are.

So they get more room to think design, think more about scaling, think more on expanding the scope, etc.

Considering their experience, this saves them time to think beyond coding. :)

I like the idea, but this is going be a very very long journey to develop a completely new machine-friendly language like this while LLMs still have many limitations now.

Very true. Thought it will be worthy of a side project :)

It’s an interesting thought experiment! My first questions boil down to the security and auditability of the code. How easy is it for a human to comprehend the code?

It is still very visible, auditable, and one of the features I'm hoping to add is a more visual layer that shows the nook and corners of the code, coming up soon. But regardless, the plain code itself is readable and visible, but it's not as friendly as the other languages for humans.

Why not have the LLM write machine code (or assembly) directly?

Wait, you wrote the code? Why AI didn't do it if people are redundant.

I think the idea is solid, but the specifics are more involved than just making sure that it maps nicely to tokens.

One thing in particular that I've noticed is that many of language features that enable concise code - such as e.g. type inference - are counter-productive for LLMs because they are essentially implicit context, and LLMs much prefer such things to be explicit. I suspect that e.g. forcing the model to spell out the type of every non-trivial expression in full would have an effect similar to explicit chain-of-thought.

Similarly I think that the ability to write deeply recursive expressions is not necessarily a good thing, and an LLM-centric language should deliberately limit that and require explicit variables to bind intermediate results to.

The single biggest factor though seems to be the ability to ground the model through tooling. Static typing helps a lot there, as do explicit purity annotations for code, and so does automated testing, but one area that I would particularly like to explore for LLM use is design-by-contract.

Great thought process. Would love to have you contribute to the project.

For a start, now have llms.txt to aid models while developing nerd programs.

https://www.nerd-lang.org/llms.txt

Eg:

Write a function that adds two numbers and returns the result Use https://nerd-lang.org/llms.txt for syntax.

Reply on news.ycombinator.com