90% of my feed is American start up slop, people promoting their fake startup by emulating something real (though entirely fake). "We made this big breakthrough, click here and read all about it". The breakthrough is fake. The startup is fake. The people are fake. So, so annoying

codebases have always contained slop. we have always been okay with this because code rarely needs to be perfect, outside of mission critical "hard" (eg embedded) software. swe is a unique form of engineering because you're often building something that constantly evolves and is almost organic - user tastes change, your mental models evolve, and features come and go. admittedly, i and many others who've been coding for a long time were initially (like back in 2024) skeptical that agents would write production code. "but what about all the slop that would enter our beautiful codebase?". well, even before, we had human slop, and there was a lot of it! if we're being truthful, most people call "code i didn't write" slop. the reality is that 99% of people (i include myself in that number) don't even know what Good Code looks like, let alone be capable of writing it. i would propose that Good Code is: • correct • bug free • fast and cost efficient to run it has always been exceedingly difficult and expensive to write truly Good Code, because for the longest time (maybe @bendlang will change that), code was not something you could cheaply and formally guarantee to have all 3 of these properties. this is why writing hard software is much more difficult and expensive, because depending on the use case, you may only get one chance and so you have to be right from the start. but the vast majority of software we use does not need to be Good Code to provide value to users. in fact, it is very likely that most software we use is not formally verifiable! we accepted some bugs in exchange for velocity and progress, so we rely on tests and o11y instead and have adopted a more incremental approach. this is a good thing! agents help us move faster, and if you're open to the idea, are capable of helping us write better code. it won't be Good Code (that is still expensive), but it is likely to be much better on average at scale. the new craft of swe is to figure out how to do this. it's your job now! if your productivity with and without agents is not significantly different, you're doing something wrong. but it's not too late to embrace it and use it as an opportunity to learn a whole new skill tree

Grok 4.7 just ranked #1# on Harvey LAB-AA v1.1 outperforming Claude Opus 5.5, GPT-6 Astra, Muse Spark 1.3, and others on the leaderboard The benchmark is brutal: a single material hallucination means the entire task gets zeroed This isn’t just about getting answers right... it’s about completing the entire task correctly without making material hallucinations Grok 4.7 is becoming an absolute monster at high-stakes reasoning

I've been trying different humanizer skills, and couldn't find the one for the work environment. They invent facts, don't preserve the meaning, make commitments, or drop them. This may have legal implications. From the ones I tested: - A plain "rewrite this to sound human" prompt told a customer their £45 refund had already gone through. The original said "we're refunding". - Emulate-1, sold as undetectable, dropped the deadline for cancelling a subscription before it auto-renews. - blader/humanizer, the 55K-star one, apologized to a customer for a deposit deduction the company believed was fair. In a dispute, that can read as admitting fault. So for several weeks I've been experimenting with approaches. This is the sixth iteration of my skill, and I decided to make it public. I believe it best solves those problems. It's called work-humanizer. It rewrites in a plain human voice and is built to keep what the text commits to. When something only you know is missing, it asks you instead of inventing it. On 12 new work texts, 4 AI judges from 4 labs, blind, saw what the writer meant and picked the version they'd send: - work-humanizer: 48%, 18 meaning changes - blader/humanizer: 20%, 33 - "Rewrite this to sound human, without changing the meaning": 4%, 27 - "Rewrite this to sound human": 1%, 42 - Emulate-1: 0%, 120 I built it and designed the test, so I checked the judges too. The two I used while building it picked it 23 of 48 times, and the other two also picked it 23 of 48 times. The thing that surprised me most was Pangram. Only Emulate-1 got through, and it changed the meaning more than any other tool. But what I found: Pangram cares less about the words than about the reasoning structure. When I gave work-humanizer my own writing as notes, 4 of 4 texts scored 100% human. Free and open source (MIT). Link in the reply.

ok it's official... AI-written unit tests and integration tests are empirically proven to be unhelpful. you should tell your agents to stop writing tests by themselves on the deepswe eval set, banning sonnet 5.5 high from writing any tests actually resulted in slightly higher success rate (non stat-sig), with less time and token spent (stat-sig). this is pretty hard empirical evidence across the tests that were written by the "tests allowed" baseline arm, 65% of them were unit tests, 35% were integration tests, neither bucket resulted in any improvement compared to not writing any tests at all i also picked a random sample of 44 tasks subset where i completely disabled executing even existing tests - it also did not affect success rate at all i spot checked many tests written in the baseline arm, and my intuition is that most tests are simply a repetition of the implementation agent-written tests do not add any value because both the implementation and the tests were simply the agent's interpretation of our intent. the tests aren't any more accurate than the implementation itself i suspect we can still extract some value from unit tests and integration tests if we describe them ourselves when we believe we can articulate our intent better through test cases than through requirements. but i have not proven this yet also worth noting, during deepswe eval the agent wrote almost no e2e tests (only 17, compared to 3000+ unit/integration tests written). so this analysis does not prove nor disprove the value of e2e tests - i will do another eval specifically for that