Pinned Tweet
we try really hard to make good programming languages to abstract the machine, but then users add 0.1 to 0.2 and it all goes to hell
Andrei Lisnic retweeted
We used to talk about a "pit of success".
Humans would be dragged towards writing the right code by well-designed API's, a good test suite, sensible lint rules.
You couldn't make the pit too steep, otherwise the humans would get annoyed. There was a social contract.
Feels like what we need now is a black hole of success. An inescapable event horizon agents cannot cross.
Agents don't feel annoyed, so you can crank up the pressure to infinity. There is no social contract to break.
In other words, increase the forces on agents to the maximum. Make great code inevitable.
Andrei Lisnic retweeted
I find it significant that the most AI-pilled people I know use AI for basically everything…except for writing
It’s remarkably consistent. Why? Because to write is to think. And outsourcing your critical thinking to AI is intellectual suicide
something that keeps bothering me is how some people see slop as something that is happening to them, like they're some kind of helpless bystander powerless to do anything about it
excuse me but you are a software engineer, you literally learned how to make sand think and make computers do your bidding?! and now you can't do anything about it? please
the 2 things you should know to cut through all the noise:
1. you need to give your agent a way to verify its own work (i just posted about this so won't rehash)
2. your codebase is memory
the 2nd is not new either, we have always had lint rules, compilers with good diagnostics and strong type systems, LSPs, etc to help us write better code. there is no difference when agents write the code instead, you just need more of them, and stronger ones.
forget rules and skills. you can add those later.
yes, your codebase is a form of memory to agents! agents love extending what already exists. so every nit and every annoyance you've ever seen, every mistake and bad pattern you observe from agents, needs to turn into a constraint, or the agents will just keep repeating those same mistakes like a virus in your code. then you keep observing and repeating this process until your codebase is locked down enough that even agents with little context can one shot a high quality PR.
an even better direction is to refactor/rewrite your code such that agent anti-patterns become categorically impossible. use type systems to your advantage, use libraries/frameworks that reduce the architectural search space, or heck, create your own framework like we did for grok bot and design high quality primitives and well thought out APIs
Interesting idea
IMO the only tests you should have in the age of coding agents are, in order of priority:
1. Full E2E tests. Nothing mocked out at all. Can even be something that runs in prod on test accounts via Playwright or equivalent.
2. Integration tests. Agents make more mistakes as things bleed between data/API boundaries where schemas can drift.
3. Golden tests. This helps ground the code with real examples of data, and can be used as regressions against edge cases.
Unit tests are bloat 99% of the time if you’re using a frontier model since they’re smart enough now to get the implementation (and subsequent iterations) right on the first shot, so they only add bloat at this point.
14
Andrei Lisnic retweeted
This is the way. Accept code on merit and ensure that a person takes accountability for it. Doesn’t matter if it was typed, chiseled, generated, or bit-flipped via magnetized needle on a chip.
If it’s good, it’s good. If it’s slop, it’s slop.
KDE is working on an official AI / LLM policy, and it reads like the rules of Fight Club.
In short, KDE’s AI policy:
1) Encourages using AI, as long as a human is kept “in the loop”.
2) But you can’t tell anyone that you used AI.
“Don’t disclose LLM usage”.
“Don’t add ‘Assisted-by: [some LLM]” (as is done in the Linux kernel).
“Nobody in KDE should know if you use an LLM”.
In other words: “Welcome to developing KDE with AI. The first rule of developing KDE with AI is: you do not talk about developing KDE with AI.”
invent.kde.org/plasma/plasma…
Andrei Lisnic retweeted
Lots of talk recently about software complexity, about the importance of simplicity and clear lines. That's always been the job, but it comes in and out of focus as fashions change. Everything must be intelligible to be maintainable, whether the intelligence is human or not.
Andrei Lisnic retweeted
There's lot of excitement around faster pretty printers using Rust. The main issue is that none of them match the long tail of formatting logic of prettier.
I'm putting up a $10k bounty for any project written in Rust that passes > 95% of the prettier JavaScript tests.
I think the next step in technological breakthroughs is put a offline #chatgpt4 in every pocket
1
95
Andrei Lisnic retweeted
@saltedge reveals an #opensource solution for strong customer authentication & dynamic linking under #PSD2. Salt Edge Authenticator securely handles all the actions where #SCA should be applied and aims to bring safety & innovation to the #payments market: https://teapawt.net/t.co/cSaFEE1v47
Andrei Lisnic retweeted
A good bug is like a good joke. The description sets up a contradiction between two premises; the investigation slowly ramps up the tension between them; then the diagnosis hits like a punchline, providing a surprising resolution.
And then you either laugh or groan. – at Cupertino, CA
Andrei Lisnic retweeted
The quickest way to ruin the productivity of a small company is to have it adopt the practices of a large company.
Andrei Lisnic retweeted
Pre-compiling templates in Rails can finally become a reality. This is geat!! johnhawthorn.com/2019/09/pre…
Andrei Lisnic retweeted
Here's what I've been working on for the last year: Execute Program, a new way to interactively learn programming tools and actually remember them afterward. We launch with three courses: TypeScript, Regexes, and the JavaScript Array API. executeprogram.com
Andrei Lisnic retweeted
The @GitHub Semantic Code team just made it easier to navigate code.
You can now jump to a function or method's definition within the same repository by clicking the function or method call in a file. 💥
github.blog/changelog/2019-0…
Andrei Lisnic retweeted
Before creating Handlebars I knew next to nothing about parsers. Same deal.
Let your ambitions, not your existing skills, be your guide.
6 years ago, I wrote a blog post debating @dhh's critique of extracting business logic from controllers. Today, I revisit that post after 6 years of personal and professional development. Read more at alisnic.github.io/posts/rail…
2
2




















