@josevalim
Account based inPoland
About this account
- Account based in
- Poland
- Connected via
- Web
Account-level information from X, not a live location or the device used for a specific post.
Creator of @elixirlang. Chief Adoption Officer at @dashbit, where we build https://nitter.cf/t.co/FK8F4URbVG and https://nitter.cf/t.co/xncEVrvWml.
Kraków, Poland
Joined November 2007
- Tweets2.8K
- Following93
- Followers56.1K
- Likes2.3K
Pinned Tweet
It is finally here: Tidewave now supports Claude Code and OpenAI Codex.
Tidewave unlocks the full-stack potential of your favorite coding agent by tightly integrating it with your web app and web framework at every layer, from UI to database. More info 👇
José Valim retweeted
Trying out Tidewave this week and just used the UI Variant feature. This felt like a missing piece of the agent puzzle. Tidewave itself is also a joy to use.
Offering a Rails World trial was a great move because you might have a new paying customer here!
José Valim retweeted
Recently, I had the chance to interview @josevalim for @_maintainable about designing a language we can maintain for decades.
maintainable.fm/episodes/jos…
José Valim retweeted
one shot
Claude Opus 5.5, xHigh reasoning
prompt:
make a dynamic 15 second motion graphics video that shows what an incredible tool tidewave is
José Valim retweeted
software is far from solved. a glimmer of ponderoos as to what 2026-2027 is as follows:
we need better tools, compiler engineers are about to enter into a renaissance era
when inferencing capacity is no longer the bottle neck, it becomes the compiler and verification tool chain problem.
you want a decent amount of back prsssure on per unit of change but if that backpressure is too slow it punishes LLM mistakes thus reduces the amount of cycles per minute.
what matters is being able to read a file, build an application and run tests in >milliseconds<
programming language authors that focus on this and utilise llms to accelerate them and their community with an intense focus on cycle times will get ahead
as
it’s a safe bet that inferencing speed won’t be a limiting factor in the very very near future.
it’s verification and how fast you can verify and pump the result back into the inferencing window.
José Valim retweeted
And we use both at @invideoOfficial! If you want to work with cracked engineers who have been using both for years, join us.
We are hiring!
José Valim retweeted
I've got an agent in a loop optimizing a renderer with the goal to minimize frame times (and tests to measure). It got times down from 88ms to 2ms and allocations down from ~150K to 500. Sounds good, right? Wrong. This is exactly why agent psychosis is a big fucking problem.
As an experiment, I rewrote the Ghostty core render state in Go, with access to identically laid out data structures as Ghostty and the exact same validation tests. I made a purposely naive renderer (simple, correct, but slow). 88ms per frame with 150,000 allocations (horrendous, lol)!
I then kickstarted a Ralph loop to bring the frame times down. I told it it can't modify input data structures or the public API or tests (they're correct), but it can do anything else it wants. It got to work.
It has worked for about 4 hours. I've spent around $350 on this experiment so far. The results?
88ms => 1.5ms
150K allocs => ~500 allocs
Incredible right? Nope.
My hand-written renderer I ported has frame times (same benchmark) of ~20us (0.020ms) and 0 allocations in the update path.
This is the problem with psychosis and lacking systems understanding. If you don't understand the system, you're going to accept that this is an incredible result. If you understand the system, you'll see better solutions immediately and can do roughly 75x better on throughput.
The people who blindly trust agent output are in the former camp. They're sheeple, overdrinking from a fountain of mediocrity.
Standard disclaimer: I use AI all the time. I like AI. The point I'm making is to not blindly accept results. Think. Analyze. Learn.
We will be running the #RailsWorld discount code for Tidewave until tomorrow night! If you want to learn how AI can augment rather than replace, give it a try! tidewave.ai/rails-world-2026
José Valim retweeted
This is obviously AI generated but it's actually a really really good explanation that matches my mental model for TLA+/Quint in many ways.
(The Lean part was a bit weird, I won't try to comment on it tho).
Quint Studio is doing the stuff explained here, reproducing counterexamples and helping you fix it but also adding test scenarios for correct but untested paths found from the model.
The auto-formalization inside Studio has amazing techniques not explained here tho, so stay tuned for that.
"The path to enlightment is full of dead ends"
- José Valim
"If you give them the answer, they won't remember it. If give them the question, they will never forget it."
- José Valim
Here is a nice pun to close the week: Rust is a system programming language, Elixir is a *systems* programming language.
Before someone "ackchyually" me, the correct version is: Rust is a systems programming language, Erlang/Elixir are distributed systems programming languages. Yes, I know the difference.
PS: the languages actually play with each other well (thanks to github.com/rusterlium/rustle…)!
José Valim retweeted
The future of programming seems certainly to be systems where change is constant and ongoing via agents, everywhere, and communicating all the time. And we happen to have a runtime perfectly suited to that. Lets go!
This was one of those weeks where too many things happened. Here is some unsolicited advice:
1. Poor unit tests are a consequence of poor design and bad practices
2. The push to formal verification is great, find where it works and where it doesn't, and then find the next thing that makes your software better
3. Communities where their sense of belonging are around ergonomics may need to reassess what brings them together when AI is writing all of the code. And token efficiency is a short-term and low-value metric to tie yourselves to. Models already got cheaper this week!
4. I receive and write dozens of AI written pull requests every week and, if I stopped reviewing code produced by AI, I am 100% confident we would have a slower Elixir compiler, buggier type system
See you next week lovely people
José Valim retweeted
seems like programming language convergence is crossing the overton window thanks to @dhh. i still stand by below, it hasn’t aged.
some programming languages will die, authors of languages who do not adapt for a changing language consumer demographic (agents). for what is the point adding sugar to a language (operator chaining) to make a language easier for humans to produce code when humans no longer write the code?
in other news; i’ve been smashing the OTP and Rust pretty hard lately. i’ve found my personal happy divide:
rust: cli, anything where memory pressure and perf need explicit guarantees (ie: network daemons or sockets) and for everything else elxir/otp. god damn these agents can attach to an actor process, observe what’s going on and troubleshoot fassst.
At the @aiDotEngineer World Fair, I sat down and dumped my brain on a podcast. Here are my latest ponderoos on these topics…
✨ Why code doesn't need to be readable by a human anymore; it needs to be explainable to one.
✨Why frontier intelligence isn't required for most tasks, and why some of the sharpest engineers I know run 20 concurrent $300/year subscriptions instead of one frontier plan.
✨ Why I haven't hand-written code in over two years, and why Git is perhaps already end of life.
✨ Why porting between programming languages is now nearly free, and what that means for which languages survive.
If by threads with shared objects, you mean threads with shared *mutable* objects, that will be a nightmare to write, maintain, and debug on top of JavaScript's event-loop, even for coding agents.
Rust has an ownership and type system specifically designed to make shared-memory concurrency safer, and I can say from firsthand experience that coding agents still struggle with it.
A huge amount of existing code relies on synchronous JavaScript running to completion within an agent. If ordinary objects could suddenly be accessed concurrently, two handlers running on different threads could observe and mutate the same object at the same time. Code that is safe today because there cannot be an interleaving between two synchronous operations could suddenly require synchronization.
That's most likely why existing JavaScript concurrency mechanisms generally rely on isolated object heaps with message passing, or explicitly shared memory such as SharedArrayBuffer, rather than making arbitrary JavaScript objects concurrently mutable.
I'd say changing such fundamental properties about the language is effectively making it worse, not better. Sound types plus AoT compilation are +1s, though.
José Valim retweeted
Not every project has a page to inspect. Tidewave IDE can now open a local directory, bringing its coding agent, terminal, Code Review, and Git workflow to libraries, CLI tools, scripts, docs, and other non-web projects
youtu.be/GjyTztkGpOU?si=x_EY…
José Valim retweeted
If we're not going to write or read the code anyway, use a technology that scales vertically and horizontally with as few moving parts as possible, like Phoenix and Elixir.
Because when you have no clue what is happening, managing Phoenix+DB will be easier than App+DB+AuthService+Functions+Redis+Whatever
If coding agents will write most of our code, what happens with our communities and sense of ergonomics? How does it impact our compilers and tools?
A friend suggested to also publish it as an article here, so let's see how it goes. You can also share and read the article on Dashbit's blog: dashbit.co/blog/evolving-ai-…