The problem is: how can you scale human code review? Because LLMs continue to be better at coding, and continue to write a lot of code, and will always code at a lower level with the time passes. So the difficulty of human review will become higher and higher.
It's clear that human review it's the very bottleneck in this workflow.
Faster definitely, but even with the latest Fable model "better" is often debatable and varies a lot based on what you care about. I can often rewrite what Claude did in 1/2 the lines or less to do the same thing while making it easier for humans to understand and maintain. Claude gives me a sculpture in a good rough starting shape, but it usually needs to be sculpted down at the end whether manually or by prompting Claude about the unnecessary bloat it generated.
While I agree with you I usually find the best output when doing the contrary of this:
> Claude gives me a sculpture in a good rough starting shape, but it usually needs to be sculpted down at the end whether manually
I make the sculpture in a good starting shape manually by writing the code that matters, data shaping, interfaces etc. It's then way more effective filling the rest following the path I created. Way better than any spec driven, as code is the ultimate spec.
The other way around makes it harder for me to fix, cause even with a lot of steering it makes things in a way i'd never introducing a bias that requires a high discipline and energy to fight back
Oh definitely, at the start of a project I always carefully handcraft the persistent data model and certain important details of APIs/messages/events used by other systems using Claude only as an assistant. Gotta ensure certain things are stable and enforce constraints where the rubber meets the road so it's safer to trust Claude's random changes to the app code on top of it.
Better models rather than plateauing is an assumption I don't want to fully depend on.
For now, more prompting and harnesses sounds like another name for more work that reduces how often LLMs save time. Reading Claude's code carefully and re-prompting repeatedly can often be faster but ironically it often feels like far more cognitive effort. That's not surprising since reading others' code is harder than your own. That's amplified by Claude's tendency toward initial bloat and making large and sometimes unrequested changes with each prompt.
Writing code has also long been a primary means for cementing and documenting our own understanding of the problem so I feel like letting the LLM drive always limits formation of our mental models for the system's workings even if we carefully read the generated code.
A major reason slop exists is because they are not "better" at coding, given some subjective criteria. They are notably worse at documentation and somewhat poor at choosing abstractions in my experience. For the most part, I witness the tools copying other examples out of the working repository, which makes them exactly as bad as the humans who originally wrote the code.
> will always code at a lower level with the time passes
For humans, this is traditionally an anti-pattern. We are good at intuiting abstractions and knowing when to use them or climb up and down the abstraction hierarchy. For LLMs, this is also an anti-pattern, because going lower-level is an exponential waste of tokens; both for writing and reading the resulting code, which they do constantly in order to understand the project again and again in order to fulfill your prompts.
Thinking of human review as a "bottleneck" is incorrect framing. We are quality control. You can choose to cede quality control to LLMs and agent harnesses, that's up to you. In my experience this generally leads to a meteoric rise in slop, because the tools increasingly resort to writing more code to solve a problem instead of updating existing code or writing the correct code. When I shake my head at some slop code, then read the slop comment that uses some slop justification that isn't real and only existed in the prompt context, I am happy that I took the time to review it. Maybe that makes me a bottleneck, oh well.
Yes of course we need. Software sucks. And sucks because there is a LOT of work to do. Always. Not only strictly programming work, right. But in fact LLMs can do also UI, UX and more.
We have a fantastic tool which is cheap and very fast. With good quality even if not great. This is a massive leap.
When I started designing Vela, on September 26, I felt something that's hard to describe. After a few hours of work I already had an interface with a taskbar, and that taskbar could open windows.
I think it was October 6 when I started using Vela as my main desktop. Since then, I've never had to go back to Plasma.
Then there's something that still amazes me: in more than a month of use, often for over twelve hours a day, I haven't had a single compositor or shell crash in my daily sessions.
Not one.
At some point I simply stopped thinking about it.
I wasn't trying Vela anymore. I was using it.
That doesn't mean there are no other bugs. Now and then, for example, I run into popup windows I can't close the normal way, and remote control with RustDesk still has trouble. And of course my experience on a single computer can't stand for every possible hardware configuration.
Vela! A new desktop environment made to use just Vulkan 1.4, expecting to be faster than Plasma* and made with wlroots, but using a custom renderer. It has focus on fractional scaling, sharpness and usability. Take a look at https://velade.org
*currently building a benchmark suite, reaching approx. 40% less ram usage, 40% faster input lag, less cpu usage in some activities, and faster responsiveness during high cpu usage (from other tasks)
I found it bizarre when Microsoft moved the Windows start menu from the corner (Fitts' law, corners are infinite-size targets), and I see you've done the same. Why?
Thanks. Fractional scaling was one of the foundation of Vela: it is really one of the reasons why Vela exists. So I thinked about it since the first minute. The issue is of course that something like at 125% with logical coordinates don't always came at actual physical pixels. And even small rounding can cause blurry text.
So in Vela fractional scaling works everything in logical coordinates until the rendering stage, then it rounds to physical pixels. If you want to deep dive: https://github.com/vela-desktop/vela/blob/main/docs/renderer...
Well, first full disclosure I'm an occasional KDE developer. Most of that code is useful and there isn't much code that is widely considered to be unpleasant to work on or doing badly on performance metrics. About Vulkan - the compositor is mostly blitting textures into rectangles - you are not going to increase fill rate much by using an API that allows faster state changes. Vulkan is a good choice for an entirely new compositor, but not using Vulkan is not really a problem for a compositor on Linux, where OpenGL won't be removed or crippled willy-nilly.
Thanks for your time, talking with a KDE developer is important to me. The reason for choosing Vulkan was about explicit control over synchronization, resource management and frame scheduling, without having to maintain also OpenGL; even though I don't exclude a software rendering fallback for VMs or something. It wasn't a first-minute choice, I realised it when I wanted to improve performance compared to other DE. Currently I'm developing a benchmark suite, this is not complete yet but I've already found out Vela around 40% lower input-to-display latency in one of my tests (compared to Plasma), apparently thanks to late latching.
No, this is written in C (the compositor itself) and C++ (parts which talks with QT)
However, the naming problem is known and currently there is an issue open (#174)
Fable 5 is not anymore frontier and even if, I hardly believe five very small 27b models can do like Fable 5. I think this is whishful thinking more than a fact
reply