These are strong tells for an AI authored article. I know we're all tired of people saying "this is AI" as it's harmful to discussing the content of an article, but articles about AI, (seemingly!) written by AI, extolling the virtues of AI -- don't really seem to drive the discussion forward to me either.
Maybe I should have added this part. As a non-native English speaker, using AI to write RFCs, ADRs, and internal documentation, my own writing style shifted so much to the direction that my writing seems like AI.
I am also a non-native English speaker but that doesn't mean you start speaking Claudian English just because you interact with AI.
If people do not like that particular style of writing and you understand it clearly, why would you double down on it? Especially if your goal is to share your writing with the intention of them reading it?
Furthermore, why not just blog in your native langauge if that is comfortable for you?
That is fair. However, the fact that we have this discussion because I wrote the post in English, I wouldn’t reach out to my fellow engineers to discuss the matter this broadly.
I don't think the existence of this discussion has anything to do with the topic we are discussing. "I wrote this myself but I only know how to write like an AI because that's how I talk in English all the time" is a weird stance to take. Furthermore, your comments are a completely different style of writing so how are you able to write like that here but suddenly switch to Claudian English for the blog?
Regardless, my feedback to you would be to disclose AI writing if you do use it (in the blog itself, not as a reply when called out for it) or if you genuinely write like that, aspire to be better than AI generated content if you care about what you are reaching out with in the first place imo.
The rest of the blog post doesn't strike me as AI generated. Hard to tell, and personally I think "hard to tell" is about as good as it's going to get from here on out, so I give the author the benefit of my doubt.
Agree that using AI for writing is a habit we collectively need to drop immediately.
I always check out the content whenever I see accusations of AI writing because I feel people can be a bit too suspicious these days but yes, this is as close to "AI but i changed how the em dashes look" writing:
> Did Kubernetes kill Ansible? Kind of. I haven’t written an Ansible playbook in years - if you handed me one right now I’d be squinting at the module syntax like I’d never seen it before - not because configuration management stopped mattering, but because Kubernetes...
Your idea that the AI is writing articles saying AI is good is very funny though
It's frustrating to find AI so prevalent in writing. It takes some nugget of a human written idea, dilutes it and increases word count, only to make the actual core idea less obvious (or ultimately summarized by someone using AI).
While it’s impressive work from the LLM and a TS implementation is novel, there’s at least a couple of pre-existing Python REs eg. https://github.com/jya-dev/supernote-tool :)
It seems like most of these "an LLM solved this in only X hours! " could have been "I found an open source solution that did what I needed with X minutes of web search."
Which doesn't mean that the LLM definitely couldn't have accomplished it without the prior art (in either the training set or explicitly in a a web search). But it does seem to be a trend.
For all the agentic loops people seem to have come up with, the research loop or as I call it the “Desperate 10th page on Github’s crappy search results” is still not up to the mark.
Either it might be genuine rate limiting these LLM’s face or just that, they are trained to focus on implementing a solution which would be faster and user acceptable solution. (which seems to be a true looking at people pushing LLM generated code as is).
At least in my personal experience with niche projects and heck even with well documented and famous libraries, along with fancy mcp’s, llms.txt and skills; RTFM has been more relevant than usual for code that I have asked an agent to generate, since it is too eager to reimplement functionality which already exists, only if it RTFM!!
If give an AI the full set of files it needs to RE a file format, and it's running xxd in tool calls in order to document the file format, I don't think it's cheating by copying it off the Internet.
It might be reverse-engineering it, but it also might be kayfabe. (Kayfabe is what professional wrestlers do - the storyline and matches are scripted, but it's presented as real. LLMs excel at doing this.) Similar to how Anthropic showed that their LLMs appear to "think ahead" when writing poetry to come up with a rhyme[1], so too might the knowledge of a file's structure influence how the LLM approaches analysis.
As a simplistic example, suppose one section of the file is known by the model to be bzip2 compressed - the LLM may use xxd to scan for common magic numbers that "just so happens" to include 42 5A (Bz). Every step of analysis is like this - what threads to look for, and which ones to pull on. Somebody or something who mostly-remembers the answer is going to find the answer quicker than if they'd gone in blind.
Haven't used docker sandbox but you can't just `apt install postgres` on firecracker, it needs to get baked into the image first.
That's my experience anyway, there's a lot of restrictions once you need to do some real basic things. For basic prompts maybe but interacting with a full stack ehh.
So bit hesitant to call firecracker a real VM myself.
I work remotely, and when trying to discuss concepts with others, I frequently doodle things out with pen and paper (just like I used to on a whiteboard in an office). Having a Supernote means I can share my diagrams live on the call, just like a real whiteboard, which in turn makes it easier to communicate with my coworkers.
I've used all kinds of drawing apps on the web previously, and the extra impedance of the mouse/canvas/tool selection/whatever frustrates the whole process.
I’m not excited about using Opus 5, mainly because the way that I work atm — essentially peer programming — means I sandbox the agents and work with them closely. Opus 4.x encounters the sandbox and moves on with its day; Fable becomes increasingly fixated on it and does less and less of the actual task, focussing more and more on the limit it reached. I worry that, from your description, Opus 5 will do the same.
It does feel a bit smarter, but it seems to be also "too clever by half" and its not ignoring the rules, it's rejecting them and finding work arounds. It sticks to the word of the law, while rebelling against the spirit of the law.
One example is to get around a git --checkout usage ban, it CD'd to another folder first and back to bypass the regex in the hook.
Ive been using btrfs snapshots and some auto generated isolation rules plus a git ceiling at the mount root for the btrfs image (have to do this in wsl, stupid work computer). it's worked really well and fable hasn't had any issues with the "sandbox" (obviously not really but it works well enough)
I've been using something similar with ZFS, 15min frequency with autopruning (Sanoid) and the snapdir mounted for the agent. Has worked well and a big plus is being able to tell the agent to just solve it's mistake via restore from the snapdir.
Even well-supported, well-documented projects. I'm in the middle of a Spring Boot upgrade, which includes a collection of Hibernate updates. These are well-supported projects with -- theoretically -- fantastic documentation. But when something goes wrong, trawling them for what's happened is tedious and doesn't teach me much; you end up chasing down uncommon threads. The death of StackOverflow doesn't help much either. Previously, web searches might have found a commiserator, but that's all gone now.
A concrete example: during one of the updates, previously working code started throwing an OptimisticLockingException. Only in one place, annoyingly. My thought was that Hibernate was more strict about something it had previously been lenient about. I went down two or three false threads in the docs; I debugged the old version and the new version and read the guts of Hibernate but couldn't figure out why the persistence path had changed so significantly (or why it'd throw an OptimisticLock, it was saving a brand new row!). I was really struggling.
I set Opus on it, and it found the relevant section of the docs and zeroed in on the issue in the code: we were generating and setting an ID on a class that had an annotated @GeneratedValue. Old Hibernate said "whatever"; new Hibernate changed the persistence code so in this situation it calls `merge` instead of `save` (update rather than create AFAICT); there was no existing entity with the generated ID (of course, it's a new entity!); it fails.
While my hypothesis was broadly right, that _particular_ issue would've taken me days to chase down -- but the LLM correctly diagnosed in minutes with links to relevant documentation.
I vaguely hate LLMs, but this one saved me from a days long side quest that would've held up delivering the actual value of the project. I hope this doesn't sound like my brain is no longer functioning.
(edit -- reading it back I'm starting to write like one of the fucking things, which is probably the part of them I hate the absolute most)
I love my Forma. The only thing about it that makes me sad is the micro-USB port. I skipped the Sage because it was a side-grade (USB-C but worse battery), and now they've discontinued it with no clear future for the format.
I really hope they bring back a similar format ereader in the future, I don't really want to go back to a smaller scale device when this one dies.
I think what folks want, but aren't quite able to articulate, is an ongoing community and effort that indicate a project will be healthy and maintained. We want to be able to rely upon the software that we are choosing to use.
Regardless of the technical choices, whether Rust is better or worse, whatever -- pgrust popped into existence thanks to one person driving an LLM through 7000 commits in ~2 weeks. It produced something that passes the regression tests. Even as an LLM-sceptic, I think that's amazing.
From that point, though, it appears to have been completely abandoned. There hasn't been a commit in a month, other than a brief tweak and a note that an as-yet unpublished version that's even betterer is in the works. IDK. I don't think we've acclimated to the shock of the change LLMs create, but if the outcome is a forest of exciting new projects that have a bus factor of 1 and little to no collaboration, I think that's a disservice to this profession.
I am not saying anything about the viability of that particular project; just that one argument that was repeatedly made in that thread which I think is frankly nuts.
Yeah. I guess what I'm saying is that I feel like we're all still stuck debating these things on technical merits alone. The `bun` rewrite and `pgrust` both expose something -- I find, at least! -- uncomfortable about how we understand the technical side of our profession, but I think the social side remains the same.
Exciting, but I’d give a lot for an equivalent to Django. There are very few problems I need to solve that are fixed by htmx style “full stack” apps, but many that are solved by the generated admin, authentication framework, caching, eventing etc.
Unfortunately, you end up bound to Python’s poor performance and poor typing stories, which Rust solves in spades.
Here's a v0.0.2 jinja2rs built on minijinja with optional python compatibility; CompatMode::Django(…) Django template language (filters, app-directory loader, auto-escape) :
When I searched for that last sentence in full, I found this:
dj-bolt/django-bolt: Rust-powered API framework for Django achieving 60k+ RPS. Uses Actix Web for HTTP, PyO3 for Python bridging, msgspec for serialization. Decorator-based routing with built-in auth and middleware.https://github.com/dj-bolt/django-bolt :
> Faster than FastAPI, but with Django ORM, Django Admin, and Django packages. [...] Django-Bolt is a high-performance API framework for Django, providing Rust-powered API endpoints capable of 188k+ RPS.
Shameless plug: I've been developing https://cot.rs/ for a while, which is strongly inspired by Django, and auto migrations, admin panel, auth, etc. are among the features supported by Cot.
reply