fcatalan

I always see these threads and think I'm not working on anything, but I just realised it's a lie, I'm exploring a couple of things right now, both heavily AI supported:

Simracing trainer.

I love simracing, I'm moderately competitive and want to improve, and I like to be efficient with my practice. So having access to and using a lot of telemetry, I noticed that the "turn a few laps, load telemetry, compare against reference lap, try again" is not as efficient as it could be.

Also a lot of my telemetry analysis is very rote and "rules based": Look at the biggest laptime delta jump against reference, try to determine the cause among a few usual suspects".

So I have started experimenting with a system that reads the iRacing telemetry in real time, and compares against the reference telemetry live, finding the biggest delta jumps, and trying to find the root cause of the time loss using an increasingly sophisticated GOFAI rule and pattern matching system. Then this report is fed to a cheap LLM call to be condensed into clear advice, and the result goes to the free Microsoft TTS API. So I get instant feedback of where I'm slow and maybe even why.

So far I fear it's mostly making me faster from all the test laps involved more than the advice itself, but when it clicks it does feel magical and really help.

But sometimes I feel like I'm just speedrunning the collapse of 70s AI, as it feels a bit too brittle and situational.

I also have added additional tools for tracking improvement across sessions, finding statistically problematic corners (where am I plain bad?, where am I inconsistent?) or even training my muscle memory by tracing fast driver brake traces using my pedal.

Yay compiler: The other ongoing thing is a clean room reimplementation of Jon Blow's Jai. I've been curious about the language for years, but it's a closed beta and for some reason I've never felt about asking Jon to get into it. I'm not really a game dev so I wouldn't even know what to put in the request.

So now I have 100k+ lines of Rust that can compile a very significant subset of the publicly available Jai source code. I just used various LLMs to condense the public information about the language and come up with a dev plan and started chipping at it. Once I had something in a kind of working state I started with the Way to Jai big tutorial and make sure every example there compiles and works as intended, fixing errors or missing features one by one.

I mostly use Claude Code or Codex, but sometimes what I do is having them guide me into the new feature and doing the edits myself while they explain, so I get to know how things really work under the hood.

It's a silly pointless project, but for some reason I find very satisfying watching it compile the examples.

Sure fire away maybe this time something clicks for someone :)

For me it has been just saying "yes" when I was offered a job and when that one was getting a bit annoying someone happened to offer me another and I said "yes" too. I have ended up a bit underemployed and underpaid, but life's comfortable and safe and I have ample time to stress over hobbies instead of work.

So comfortable that lately I have declined offers for interesting and much much better paid work, because I can no longer be bothered to take any risks or alter my lifestyle.

But sometimes I wish I could have been the guy managing to get 10k MMR using knowledge I've got in spades.

100% true. I ran a top 10 most visited Spanish language site on a Pentium III server. I have the technical chops to do all the articles says.

But 10k MRR sounds to me like travelling to Mars. I have 0 ideas and 0 initiative to push them ahead.

Making complete coherent products is as hard as ever, or even harder if you intend to trade robustness for max agentic velocity.

What I do very successfully is low stakes stuff for work (easy automations, small QoL improvements for our tooling, a drive-by small Jira plugin)

And then I do a lot of crazy exploring, or hyper-personal just for myself stuff that can only exist because I can now spawn and abandon it in a couple days instead of weeks or months.

Gemini 3.1 via aistudio picked 7321, so it seems to be a shared trait. Good to know if I catch anyone doing an LLM-assisted raffle...

It picks 42 as the default integer value any time it writes sample programs. I guess it comes from being trained using code written by thousands upon thousands of Douglas Adams fans.

I'll raise the flag of "Don't nickel and dime me" in every battlefield.

Same originating idea: "a language for AI to write in" but then everything else is different.

The features of both are quite orthogonal. Cairn is a general purpose language with features that help in writing probably working code. Mog is more like "let's constraint our features so bad code can't do much but trade that for good agent ergonomy".

Cairn is a crazy sprawling idea, Mog is a little attempt at something limited but practical.

Mog seems like something someone has thought about. No one has thought about Cairn, it's pure LLM hallucination, the fact that it exists and can do a lot of stuff it's just the result of someone (me) not knowing when a joke has gone too far.

Superpowers is literally a bunch of skills packaged in a Claude plugin

A couple weeks ago on a lark I asked Claude/Gemini/Codex to hallucinate a language they would like to program in and they always agreed on strong types, contracts, verification, proving and testing. So they ended up brainstorming a weird Forth-like with all those on top. I then kept prodding for an implementation and burned my weekly token budget until a lot of the language worked. They called it Cairn.

So now I prompted this: "can you generate a fizzbuzz implementation in Cairn that showcases as much as possible the TEST/PROVE/VERIFY characteristics of the language? "

Producing this (working) monstrosity (can't paste here, it's 200+ lines of crazy): https://gist.github.com/cairnlang/a7589de126b14e50a53b9bdc28...

You tell the agent to write a whimsical tutorial book about the language, it takes about an hour :)

This enables different satisfactions. You can still choose all your options but have a working repl or small compiler where you are trying them within minutes.

Also you decide how much in control you are. Want to provide a hand made grammar? go ahead, want the agent to come up with it just from chatting and pointing it to other languages, ok too. Want to program just the first arithmetic operator yourself and then save the tedium of typing all the others so you can go to the next step? fine...

So you can have a huge toy language in mere days and experiment with stuff you'd have to build for months by hand to be able to play with.

My own 100% hallucinated language experiment is very very weird and still has thousands of lines of generated examples that work fine. When doing complex stuff you could see the agent bounce against the tests here and there, but never produced non-working code in the end. The only examples available were those it had generated itself as it made up the language. It was capable of making things like a JSON parser/encoder, a TODO webapp or a command line kanban tracker for itself in one shot.

Ugh sounds like work, we are vibing here. Or can we also vibe-science? :)

I agree, it´s mostly a silly whim taken too far. Too much time in my hands.

In particular the whole stack based thing looks questionable.

In fact the very first answer by Gemini proposed an APL-like encoding of the primitives for token saving, but when I started the implementation Claude Code pushed back on that, saying it would need to keep some sane semantics around the keywords to be able to understand the programs.

The very strict verification story seems more plausible, tracks with the rest of the comments here.

What has surprised me is that the language works at all, adding todo items to a web app written in a week old language felt a bit eery.

There's a lot of language for such a little time, but if you have programmed any Forth it should be easy to pick up, have a look at some of the top level examples.

I have programmed about 3 Forth implementations by hand throughout the years for fun, but I have never been able to really program in it, because the stack wrangling confuses me enormously.

So for me anything vaguely complex is unreadable , but apparently not for the LLMs, which I find surprising. When I have interrogated them they say they like the lack of syntax more than the stack ops hamper them, but it might be just an hallucinated impression.

When they write Cairn I sometimes see stack related error messages scroll by, but they always correct them quickly before they stop.

I have had to check myself a bit, too easy to fall too deep into what is essentially a practical joke

It has been on the roadmap since they invented the thing. I fear it won't work but then they probably will do it in 10 minutes...

I have let Gemini, Claude Code and Codex hallucinate the language they wanted to for a few days. I prompted for "design the language you'd like to program in" and kept prompting "go ahead". Just rescued it from a couple too deep rabbit holes or asked it for some particular examples to stress it a bit.

It´s a weird-ass Forth-like but with a strong type system, contracts, native testing, fuzz testing, and a constraint solver for integer math backed by z3. Interpreter implemented in Elixir.

In about 150 commits, everything it has done has always worked without runtime errors, both the Elixir interpreter and the examples in the hallucinated language, some of them non-trivial for a week old language (json parser, DB backed TODO web app).

It´s a deranged experiment, but on the other hand seems to confirm that "compile" time analysis plus extensive testing facilities do help LLM agents a lot, even for a weird language that they have to write just from in-context reference.

Don´t click if you value your sanity, the only human generated thing there is the About blurb:

https://github.com/cairnlang/Cairn

It kind of feels like it wants to go there or thereabouts, but to be honest, I just half understand half of the roadmap it has written for itself:

  - **v0.0.1** (complete): Interpreter, PRE/POST contracts, REPL, TIMES/WHILE, FILTER/MAP/REDUCE, strings, I/O
  - **v0.1.0** (complete): Static type checker, VERIFY (property-based contract testing), maps, Safe Bank milestone
  - **v0.2.0** (complete): PROVE — compile-time contract verification via Z3 SMT solver
  - **v0.3.0** (complete): Algebraic data types (TYPE/MATCH) — Option, Result, and user-defined sum types with exhaustiveness checking
  - **v0.4.0** (complete): JSON parser/encoder milestone — wildcard MATCH, string primitives, ROT4, PAIRS, NUM_STR, VERIFY for sum types
  - **v0.4.1** (current): PROVE for IF/ELSE branches (via SMT-LIB `ite`), ABS/MIN/MAX, function call inlining
  - **v0.5.0** (next): Practical language features — LET bindings, IMPORT/modules, error handling, standard library
  - **v0.6.0**: PROVE for MATCH/algebraic types, refinement-style reasoning
  - **v0.7.0**: Typed BEAM concurrency (typed message passing, stateful actors)
  - **v0.8.0**: BEAM bytecode compilation
  - **Future**: Declarative constraint solving, tensor/distribution primitives, multi-agent collaboration

I'd say the sky is the limit, but in fact the limit is the stingy token budget of the 20€ Claude sub...

Spawns and calls z3 under the hood, I did let it cheat there because otherwise it's rabbit holes below rabbit holes all the way down :)

I plan to keep dumping tokens into it here and there to see where it goes, it's a fun rabbit hole.

I find that it's able to produce working code in the generated language just from the README and the previous examples without much trouble. And I've seen the strict typing help it catch and correct bugs quickly. I steer it very little. The only thing I keep an eye on is not allowing it to cheat about things like writing lots of concrete functionality in the host language and then just calling that from the interpreter.

sure, for example it generated this small demo of the type and contract safeguards. As you can see, it's mostly "Forth but with things":

  # bank.ax — The Safe Bank (Milestone 2)
  #
  # Demonstrates property-based verification of financial operations.
  # Each function has PRE/POST contracts. VERIFY auto-generates random
  # inputs, filters by PRE, runs the function, and checks POST holds.
  
  # DEPOSIT: add amount to balance
  # Stack: [amount, balance] (amount on top)
  # PRE: amount > 0 AND balance >= 0
  # POST: result >= 0
  DEF deposit : int int -> int
    PRE { OVER 0 GTE SWAP 0 GT AND }
    ADD
    POST DUP 0 GTE
  END
  
  # WITHDRAW: subtract amount from balance
  # Stack: [amount, balance] (amount on top)
  # PRE: amount > 0 AND balance >= amount
  # POST: result >= 0
  DEF withdraw : int int -> int
    PRE { OVER OVER GTE SWAP 0 GT AND }
    SUB
    POST DUP 0 GTE
  END
  
  # Verify both functions — 500 random tests each
  VERIFY deposit 500
  VERIFY withdraw 500
  
  # Prove both functions — mathematically, for ALL inputs
  PROVE deposit
  PROVE withdraw
  
  # Demo: manual operations
  1000 200 deposit SAY
  1000 300 withdraw SAY

Running it outputs:

  VERIFY deposit: OK — 500 tests passed (1056 skipped by PRE)
  VERIFY withdraw: OK — 500 tests passed (1606 skipped by PRE)
  PROVE deposit: PROVEN — POST holds for all inputs satisfying PRE
  PROVE withdraw: PROVEN — POST holds for all inputs satisfying PRE
  1200
  700

A few days ago I asked Claude what kind of language it would like to program in, and it said something like Forth but with static typing, contracts, and constraint solving, implemented on the Erlang BEAM.

So I have been prodding Claude Code for a few sessions to actually do it. It's a silly experiment, but fun to watch. Right now it's implementing a JSON parser in the generated language as a kind of milestone example.

The charge of the Rohirrim in Return of the King also works for me

I didn't know Sogno di Volare. It does work very well, quite intense.

I got me thinking... I've never taken any mind altering drugs, so I wonder how the experience compares. I guess that even if not in the same league, being "free" and without apparent side effects this is quite the "feelgood" bang for the buck.

I non-ironically got them chills just by hearing a few bars while checking your link.

I tend to go for this one https://www.youtube.com/watch?v=qIhZbvlCjY0 because although I can´t read music I can kind of vibe-read the score by looking at the waves of notes following the music. For me it adds to the experience.

Also the almost organ-like effects of the two separate orchestras seem stronger in this recording than in any other I've tried.

I get chills from music here and there. The piece that most reliably will produce the strongest effect on me is "Fantasia on a Theme by Thomas Tallis" by Ralph Vaughan Williams.

Looking at the article there seems to be a genetic component, but no one in my family has ever mentioned them, I should go ask.

We are not a "musical" family. No one plays competently any instruments or goes to concerts. I have an ukulele that I use mostly as a noisy version of a fidget spinner.

From the article I see that the openmindedness trait fits, at least musically: I sometimes go on YouTube musical late night binges and they can easily range from Renaissance guitar pieces to KPop via Mozart, Slipknot or some obscure Latvian folklore.

Yes. I could get over the 1300 hump and at least make general sense of everything past there because I have read about half of Ōsweald Bera