After being cut off from Fable, I integrated Deepseek-4 to be callable as a local OCaml function and then built unikernel-style sandboxed agent libraries from the ground up. Language integrated LLMs are surprisingly easy to put together, given a sufficient supply of local memory and a tolerance for slothful responses anil.recoil.org/notes/langua…

When I struggle to structure my thoughts about what's happening I turn to writing. Today about the recent US Anthropic ban news, what it says about power and dependency, and what it should mean for Europeans and citizens of the world. It's a long one. lucumr.pocoo.org/2026/6/13/a…

LLMs are like children: if they've been quietly keeping themselves busy for too long you should probably check what they're up to

If your "Flow vs TypeScript" take is from 2021, it's out of date. Flow looks like TypeScript now - but it has pattern matching and React component syntax, while catching runtime crashes TypeScript waves through. Examples below. 👇

A few nice upgrades landed in pkg.pr.new recently 🚀 • .tgz publish support • some UI polish npmx button • commentId output support • fixed badge generator URLs • SEO OG image • fixed branch/PR-number based versioning • increased payload limit to 120MB

English video: DwarfStar distributed inference demo, theory and implementation: youtu.be/aAWdlLfJmqw

These last 6 months i've been building a tech demo showcasing what I believe OCaml, its ecosystem and its DX could grow into. I started with the Riot ecosystem I had been building a few years back (scheduler, tui, web framework, etc), and then I added one tool, and another, and then it got out of hand. The end result was a complete platform that I genuinely enjoyed using daily to build all sorts of tools, almost all of it AI-assisted! It's a pretty great way of building with OCaml, even if its just a tech demo :) riot.ml and pkgs.ml No camels or dunes were hurt during the development of this tech demo, this isn't official OCaml stuff, use at your own risk, etc. Sources on github.com/leostera/riot <- go to drop a star! 🌟

You might believe you should spend less time thinking about code because of AI. I strongly disagree! We’re watching this play out live where tons of AI generated code becomes a liability. At the end of the day, an engineer needs to be responsible / on call for code that gets shipped to production. If you don’t understand the system you’re trying to debug, you’re probably going to have a bad time. Yes, AI can help with all of this, if you set up the proper systems. You can have agents triage prod logs, look at errors, etc. You can speed up parts of the investigation, but an engineer needs to make the call. There might be serious customer or financial implications from that change. I expect the trend continue for trimming dependencies, vendoring code so you can modify it directly, preferring simpler systems with fewer abstractions, and spending waaaay more time thinking about system design and code maintenance. I’ve said this before, but it’s a great time to get familiar with CS fundamentals and some of the history behind what great software looks like. Many parts will be different in the coming years as AI progresses, but also a lot more than people realize will stay the same.

i've been thinking a lot about how to encode repeatable quality checks for my agents without spending a lot of energy/effort/tokens into making custom lints for different linters, and without it being too slow to execute! cons for just using agents here is: * non deterministic, might miss checks! * slow, boy i need to save me some ms and one llm call per group of files is just not scalable * expensive, tokens burn like crazy if you use it on every commit and so lintbook was born: author lints with llms in simple .md files, execute generated datalog queries * deterministic: its just datalog queries! * fast: a ~30k project runs in ~300ms * cheap: only uses tokens when compiling lints github.com/leostera/lintbook

Thoughts on Bun’s port from Zig to Rust Background: back on ReactJS I sometime helped refactoring the Facebook monorepo when there’s a breaking React API change. I then led the conversion of Messenger web from JS to ReasonML. Given those experiences, I think there’s some interesting parallel to @jarredsumner's refactor of Bun that the programming community isn’t picking up. There are refactors of 100 lines that’d take days to verify, then there are refactors of 100k lines that’d take minutes. “Refactor” is a large word and most folks associated it with structural changes (which is indeed what a worthwhile refactor should be and what most folks are exposed to). However, what Bun did is actually to intentionally preserve existing structures through situation-specific, syntactic and semantic invariants. In other words, pretend that Bun whipped up something between a bunch of seds AST macros and a proper transpiler, then transpiled the codebase. Such codebase-specific transpiler would treat the tests passing to be not just about the concrete tests themselves, but about them validating representative semantic “corners” of said transpiler (In which case the correctness of such refactor increases up immensely bc tests represent generalized semantics). Now tackle on the fact that Claude helped accelerating the making of this virtual transpiler from, say, 70 days to 7, then this all adds up. One additional note is that such transformation is more dangerous if it was Rust -> Zig. But here it’s from a less safe lang to a safer one (I like Zig so this isn’t a subjective vote. Anything that makes languages more like Jai is probably good for agentic usages). Now here’s the exciting point I’m trying to reduce this situation to: the LLM (Mythos?) itself acted as this premade, ad-hoc transpiler, which imo is a much more fun, and much less discussed perspective. There’s a very strong argument (and soon, more empirical evidence) that a specially-posttrained LLM, along with inference determinism and some lower-level traditional compiler helpers, can act as an optimizing compiler one day. Pretty exciting era we’re entering!

Well done to Skrillex on winning the 2026 Eurovision Song Contest with Bangarang

OCaml people: What is the the expected timeline for migrating OCaml 5.0 's untyped algebraic effects to effects that are actually tracked in the type system? How far off is it? Is there a concrete plan?

This is not to diminish this talk by @yminsky, because it's an amazing one. You should watch it. youtu.be/rUYP4C29yCw?si=FAS9…

Every time I read OCaml code written by others... Give your code a little space to breathe, will ya? (example from here: youtu.be/rUYP4C29yCw?t=1540)

we love using ReScript & Elixir. Elixir is a perfect fit for managing our agent loops (GenServers / Phoenix), and ReScript is a blessing to manage the ever growing complexity of a React frontend codebase. Now that the agents are writing the code, there are no excuses left ppl

With Bun's move to Rust, it's clear that with agentic engineering, projects will be rewritten in languages with stronger type systems and more comprehensive compile-time checks. What was friction before now allows you to move faster with fewer errors.

it seems that when Frontman gets to do a frontend task, it beats generalist agents! (looking at you @claude_code and @opencode ) LinkedIn style: link to the comparison in the first reply

we(well mostly @itayad ) just deleted 1.5k LOC from Frontman client side, mostly old experiements we run that we nevered bothered cleaning. The real power of @rescriptlang with agents is that if it compiles(especially after deletes) it'll work. that's the difference between static typed vs soundly typed.