News for hackers. Stuff that matters.
Re:Kotlin creator's new language: a formal way to talk to LL... by lifis on Thursday March 12, 2026 @11:38AM (#47352366)
As far as I can tell it's not a new language, but rather an alternative workflow for LLM-based development along with a tool that implements it.

The idea, IIUC, seems to be that instead of directly telling an LLM agent how to change the code, you keep markdown "spec" files describing what the code does and then the "codespeak" tool runs a diff on the spec files and tells the agent to make those changes; then you check the code and commit both updated specs and code.

It has the advantage that the prompts are all saved along with the source rather than lost, and in a format that lets you also look at the whole current specification.

The limitation seems to be that you can't modify the code yourself if you want the spec to reflect it (and also can't do LLM-driven changes that refer to the actual code), and also that in general it's not guaranteed that the spec actually reflects all important things about the program, so the code does also potentially contain "source" information (for example, maybe your want the background of a GUI to be white and it is so because the LLM happened to choose that, but it's not written in the spec).

The latter can maybe be mitigated by doing multiple generations and checking them all, but that multiplies LLM and verification costs.

Also it seems that the tool severely limits the configurability of the agentic generation process, although that's just a limitation of the specific tool.

Re:Kotlin creator's new language: a formal way to talk to LL... by abreslav on Thursday March 12, 2026 @12:00PM (#47352772)
> The limitation seems to be that you can't modify the code yourself if you want the spec to reflect it

Eventually, we'll end up in a world where humans don't need to touch code, but we are not there yet. We are looking into ways to "catch up" the specs with whatever changes happen in the code not through CodeSpeak (agents or manual changes or whatever). It's an interesting exercise. In the case of agents, it's very helpful to look at the prompts users gave them (we are experimenting with inspecting the sessions from ~/.claude).

More generally, `codespeak takeover` [1] is a tool to convert code into specs, and we are teaching it to take prompts from agent sessions into account. Seems very helpful, actually.

I think it's a valid use case to start something in vibe coding mode and then switch to CodeSpeak if you want long-term maintainability. From "sprint mode" to "marathon mode", so to speak

[1] https://codespeak.dev/blog/codespeak-takeover-20260223

Re:Kotlin creator's new language: a formal way to talk to LL... by newsoftheday on Thursday March 12, 2026 @12:20PM (#47353182)
> Eventually, we'll end up in a world where humans don't need to touch code, but we are not there yet.

Will we though? Wouldn't AI need to reach a stage where it is a tool, like a compiler, which is 100% deterministic?

Re:Kotlin creator's new language: a formal way to talk to LL... by intrasight on Thursday March 12, 2026 @12:33PM (#47353412)
We will and soon because it does not have to be deterministic like a compiler. It only has to pass all tests.
Re:Kotlin creator's new language: a formal way to talk to LL... by my_throwaway23 on Thursday March 12, 2026 @01:46PM (#47354583)
Who is writing the tests?
Re:Kotlin creator's new language: a formal way to talk to LL... by justonceokay on Thursday March 12, 2026 @03:35PM (#47355941)
In the future users will write the tests
Re:Kotlin creator's new language: a formal way to talk to LL... by abreslav on Thursday March 12, 2026 @04:24PM (#47356525)
There are different kinds of tests:

* regression tests – can be generated

* conformance tests – often can be generated

* acceptance tests – are another form of specification and should come from humans.

Human intent can be expressed as

* documents (specs, etc)

* review comments, etc

* tests with clear yes/no feedback (data for automated tests, or just manual testing)

And this is basically all that matters, see more here: https://www.linkedin.com/posts/abreslav_so-what-would-you-sa...

Re:Kotlin creator's new language: a formal way to talk to LL... by vbezhenar on Thursday March 12, 2026 @12:59PM (#47353856)
Compiler is not 100% deterministic. Its output can change when you upgrade its version, its output can change when you change optimization options. Using profile-guided optimization can also change between runs.
Re:Kotlin creator's new language: a formal way to talk to LL... by CWIZO on Thursday March 12, 2026 @02:35PM (#47355244)
If you change inputs then obviously you will get a different output. Crucially using the same inputs, however, produces the same output. So compilers are actually deterministic.
Re:Kotlin creator's new language: a formal way to talk to LL... by jason_oster on Friday March 13, 2026 @03:47PM (#47368871)
This is irrelevant over the long run because the environment changes even if nothing else does. A compiler from the 1980's still produces identical output given the original source code if you can run it. Some form of virtualization might be in order, but the environment is still changing while the deterministic subset shrinks.

Having faith that determinism will last forever is foolish. You have to upgrade at some point, and you will run into problems. New bugs, incompatibilities, workflow changes, whatever the case will make the determinism property moot.

Re:Kotlin creator's new language: a formal way to talk to LL... by mike_hearn on Friday March 13, 2026 @03:52PM (#47368950)
Many compilers aren't deterministic. That's why the effort to make Linux distros have reproducible builds took so long and so much effort.

The reason is, it's often more work to be deterministic than not deterministic, so compilers don't do it. For example, they may compile functions in parallel and append them to the output in the order they complete.

Re:Kotlin creator's new language: a formal way to talk to LL... by abreslav on Thursday March 12, 2026 @04:20PM (#47356484)
Two things to mention here:

1. You are right that we can redefine what is code. If code is the central artefact that humans are dealing with to tell machines and other humans how the system works, then CodeSpeak specs will become code, and CodeSpeak will be a compiler. This is why I often refer to CodeSpeak as a next-level programming language.

2. I don't think being deterministic per se is what matters. Being predictable certainly does. Human engineers are not deterministic yet people pay them a lot of money and use their work all the time.

Re:Kotlin creator's new language: a formal way to talk to LL... by discreteevent on Thursday March 12, 2026 @06:06PM (#47357921)
>Human engineers are not deterministic yet people pay them

Human carpenters are not deterministic yet they won't use a machine saw that goes off line even 1% of the time. The whole history of tools, including software, is one of trying to make the thing do more precisely what is intended, whether the intent is right or not.

Can you imagine some machine tool maker making something faulty and then saying, "Well hey, humans aren't deterministic."

Re:Kotlin creator's new language: a formal way to talk to LL... by pjmlp on Friday March 13, 2026 @04:39AM (#47361967)
They do it all the time with their EULAs.
Re:Kotlin creator's new language: a formal way to talk to LL... by ferguess_k on Thursday March 12, 2026 @03:45PM (#47356081)
Why are we eliminating our own job and maybe hobby so eagerly? Whatever. It is done.
Re:Kotlin creator's new language: a formal way to talk to LL... by lifis on Thursday March 12, 2026 @12:11PM (#47353009)
Also they seem to want to run this as a business, which seems absurd to me since I don't see how they can possibly charge money, and anyway the idea is so simple that it can be reimplemented in less than a week (less than a day for a basic version) and those alternative implementations may turn out to be better.

It also seems to be closed-source, which means that unless they open the source very soon it will very likely be immediately replaced in popularity by an open source version if it turns out to gain traction.

Re:Kotlin creator's new language: a formal way to talk to LL... by souvlakee on Thursday March 12, 2026 @11:45AM (#47352499)
As far as I can tell C is not a new language, but rather an alternative workflow for assembly development along with a tool that implements it.
Re:Kotlin creator's new language: a formal way to talk to LL... by abreslav on Thursday March 12, 2026 @11:53AM (#47352651)
I second that :)
Re:Kotlin creator's new language: a formal way to talk to LL... by abreslav on Thursday March 12, 2026 @12:01PM (#47352798)
> Also it seems that the tool severely limits the configurability of the agentic generation process, although that's just a limitation of the specific tool.

Working on that as well. We need to be a lot more flexible and configurable

Re:Kotlin creator's new language: a formal way to talk to LL... by boznz on Thursday March 12, 2026 @02:45PM (#47355329)
Also a bit formal. Maybe something like this will be the output of the prompt to let me know what the AI is going to generate in the binary, but I doubt I will be writing code like this in 5 years, English will probably be fine at my level.
Re:Kotlin creator's new language: a formal way to talk to LL... by WASDx on Thursday March 12, 2026 @05:11PM (#47357164)
I think these limitations could be addressed by allowing trivial manual adjustments to the generated code before committing. And/or allowing for trivial code changes without a spec change. The judgement of "trivial" being that it still follows the spec and does not add functionality mandating a spec change. I haven't checked if they support any of this but I would be frustrated not being allowed to make such a small code change, say to fix an off-by-one error that I recently got from LLM output. The code change would be smaller than the spec change.

Cool idea overall, an incremental psuedocode compiler. Interesting to see how well it scales.

I can also see a hybrid solution with non-specced code files for things where the size of code and spec would be the same, like for enums or mapping tables.