Atlas RAT C2 protocol evolution:
- November 2025:
SFuckcheck-in and cleartext C2 headers - March 2026: XOR encrypted C2 headers
- May 2026:
BFuckcheck-in - July 2026: C2 over TLS
Search
5 results for “cleantext”
-
https://www.europesays.com/unitedstates/29970/ EV Bets Drive India’s Cleantech Funding Surge In Q3 #FollowUp #Startups #VentureCapital #VentureCapital&Startups
-
🚨 EUVD-2026-96710
📊 Score: 5.3/10 (CVSS v3.1)
📦 Product: mall4j
🏢 Vendor: gz-yami
📅 Updated: 2026-10-11📝 mall4j through 4.0 contains an improper authorization vulnerability that allows authenticated storefront customers to delete other shoppers' cart items through an operator precedence error in the cleanExpiryProdList SQL statement. Attackers can send one DELET...
🔗 https://euvd.enisa.europa.eu/vulnerability/EUVD-2026-96710
-
You’ve read way too many versions of this paragraph already. Probably even this week:
“In today’s fast-paced world, AI isn’t just a tool, it’s a paradigm-shifting tapestry. Let’s delve into this transformative realm, where the real magic happens.”
My team at Towards AI drafts a lot with AI now: videos, courses, books, articles… thousands of them. My team and I use Claude for almost everything, and too often what I have to review sounds exactly like that.So since June, I’ve been measuring which models can actually write like me. After 9,050 scripts, the surprise is that these “slop words” are quite easy to fix.
The setup
In June this year, I took ten of my own video scripts, some published and some held back to catch contamination. Four of us spent a month near full-time, about 400 hours, polishing them and turning what makes them work into (as clear and detailed as possible) rubrics.We then measure whether a model can regenerate something decent, having access to my voice guide, a storytelling guide, output rules, past examples, the brief, and the research.
We then have four LLM judges score every draft against my final version and the rubric: one GPT, one Claude, one open model, and Jev as a recent add-on.
We’ve measured 181 configurations so far, including every thinking level, and plan to measure all upcoming models as well.
But most importantly, here’s what we learned from building this new benchmark, reviewing thousands of generations, and iterating on the rubrics.
Less slop doesn’t mean better writing
Our top 15 configurations all score above 90 on the slop check, so with a detailed prompt, phrases like the one above are mostly under control.If you can’t deal with slop anymore, the cleanest of all models we’ve released out of the 181 is GPT-6 Astra at max effort: 94.9.
Still, be careful: this is just one metric we track. Astra currently ranks 62nd because it doesn’t sound like me: 82 on tone and voice, against 90 for Opus. Claude models altogether hold the top 11 spots.
The main thing I learned iterating with both models is that cutting a few Claude-isms is a quick edit. Annoying, but it takes one easy edit pass to fix. Rebuilding a voice is not. It requires a lot of mental effort, restructuring the text, changing examples… which currently makes me stick to Claude for writing.
Max effort buys very little
Opus 5.5 at max effort is the best writer we’ve measured, at 90.8 out of 100. At xhigh, it scores 90.0 for $0.69 a script instead of $2.75.That’s 4x the price for a score less than 1% higher. I settle on xhigh and keep max for the rare piece where every sentence matters.
Cheap models change the unit of work
GLM-5.3 Flash, an open-weight model, scores 88.2 for 1.5 cents a script. Opus 5.5 at max costs nearly 190 times more for a score about 3% higher.It doesn’t only mean generating similar writing with GLM is almost 200 times cheaper. It means that, used right, you can generate BETTER results than Claude for cheaper with an open model.
We also measured variability between generations. If you generate 10 drafts with GLM and pick the best one, you’ll have extremely similar results to Opus 5.5 and still be 20 times cheaper. If you add a powerful judge with a good rubric and the ability to merge sections from one draft to another to create the best Frankenstein draft possible, it should produce much better results than Opus 5.5 while costing less.
Generating is cheap now. Picking is the challenge. Spend your money on judging and picking, not on generating.
Every judge has a favorite lab
Compared with the other judges, our GPT judge adds 2.75 points to OpenAI drafts and takes 2.14 off Anthropic’s.The DeepSeek judge adds about a point to DeepSeek and Kimi.
The Claude judge has the smallest tilt, about half the others’, though it still bumps its own lab and surprisingly likes Google even more.
Jev is pretty neutral, with a small preference for the Gemini models as well, but not being able to justify its reasoning in the ratings seems to make it less consistent for our tasks, maybe because writing is more of a “system 2” type of judging.
No judge is neutral. Use a panel, and never let your writer’s lab be the only scorer.
The pipeline I’d use for writing with AI
Pick the model that gets you there with the fewest edits without making you mad, not the one that writes the most “amazing” text. Then:- Write long, very specific instructions: your voice, your structure, your rules.
- Show examples of what to do, and examples of what not to do. Name the phrases you hate, and check drafts for them in code instead of trusting the prompt.
- Add your best past pieces, in full, and ideally details on why they are good.
- Generate several drafts with a cheap open model.
- Let a high-thinking judge from another lab pick or merge the best, against a clear rubric.
- Run one or two review-and-edit rounds with a separate judge. Beyond two, I haven’t seen much help.
- Keep a human at the end. Even Opus 5.5 drafts need one.
One caveat: this measures my voice on my scripts. It’s one data point, not the truth. Test on your own writing before you switch anything! Building this evaluation pipeline has been so useful that we’ve adapted it for many of our clients’ custom tasks with great results.
I’m releasing the full benchmark, ToneBench, with the methodology behind every number here, in my talk on Tuesday, October 13 (10:40 a.m., Turing room — Evals Track). Come say hi; I’d love to chat and improve the benchmark.#ai #llm #aie #openweight #software #coding #development #engineering #inclusive #community
What 9,050 AI-Written Scripts Taught Me About Slop -
I didn't set out to "replace my workflow with AI." I set out to answer a narrower, more honest question: which parts of my job are actually typing, and which parts are judgment I've been pretending were typing?
So I took my normal pipeline — plan, write, test, review, debug, ship — and moved each stage onto an agent, one at a time, for a few weeks. I kept whatever held and ripped out whatever didn't.
Here's the stage-by-stage result. No scorecard, no "I shipped 40 PRs" number — just the shape of what won and what quietly broke.
Stage 1: Planning — the agent is great at writing a plan, bad at having one
I expected planning to be the agent's weakest stage. It's half right.Hand an agent a vague ticket — "users are complaining checkout is slow" — and ask for a plan, and you get something that looks like a plan: numbered steps, files to touch, a rollback note. It reads well. It is also frequently a plan for the wrong problem, because the agent filled the ambiguity with the most statistically likely interpretation, not the true one.
What actually worked was inverting it. I stopped asking the agent to decide the plan and started asking it to draft the plan from a spec I'd already pinned down. The judgment — what problem are we even solving — stayed with me. The typing — turning that into acceptance criteria, edge cases, a file list — went to the agent, and it's genuinely faster than me at that.
The rule: an agent turns a decision into a document beautifully. It cannot make the decision for you — and its confident draft will hide that it didn't.
Stage 2: Writing code — won, on exactly the work you'd expect
This is the stage everyone pictures, and it's the least interesting result because it's the one that just works.The agent won clean on anything where the hard part was typing, not deciding:
- CRUD endpoints with a clear schema
- a migration with a written spec
- wiring a form to an API I'd already designed
- a mechanical refactor across 30 files — and crucially, it doesn't get bored on file 27, which is exactly where I introduce a typo
- dependency bumps and the follow-on fixes
It lost on anything where the code was the easy part and the decision was buried in it: "why is this column nullable," "should this be one service or two," "is this edge case real or theoretical." The agent will answer all three confidently and sometimes wrongly, and the code it writes on top of the wrong answer is clean, tested, and shippable-looking.
The rule: agents are fastest exactly where the code is downstream of a decision you already made. The danger is they'll happily make the decision too, and you can't see that in the diff.
Stage 3: Testing — this was the real surprise, and the real trap
Writing tests is high-typing, low-glory work, so I assumed it was pure upside. It mostly is — the agent wrote months of "we'll get to it later" tests with no ego and no counter-pitch. That part was a gift.But there's a trap underneath it that took me a week to see:
If the same agent writes the code and the tests, the tests pass — and they're worthless. They don't test whether the code is correct. They test whether the code does what the code does. The agent read its own implementation and wrote tests that encode its own assumptions, including the wrong ones. Green board, zero signal.
The fix was structural, not prompt-level: the test agent is a different agent, and it gets the spec, not the implementation. Now the tests encode what the thing is supposed to do, and when they disagree with the code, that disagreement is the whole point.
The rule: code and tests from the same agent agree with each other, not with reality. Separate the author from the examiner, or you're just asking the model to grade its own homework.
Stage 4: Review — where I learned the workflow didn't actually get shorter
Here's the stage I got wrong for the longest.I added a reviewer agent to read every diff before I did. It's good — it catches the mechanical stuff fast: an unhandled error path, a missing null check, a test that asserts nothing. For that class of bug it's a better first pass than tired-me at 6pm.
What it cannot do is the review that actually matters: is this change solving the right problem, and does it break something three files away that isn't in the diff? That's the exact failure mode the code agent produces — every line individually correct, the decision wrong, and nothing in the diff looks wrong because nothing in the diff is wrong locally.
So the reviewer agent triages; it doesn't absolve. The judgment review still lands on me. And that's when it clicked: I hadn't removed work from my week. I'd moved it. Less time typing code, far more time writing specs up front and reading diffs like a hostile stranger wrote them.
The rule: a second agent reviewing the first agent's work catches typos, not decisions. The judgment review is not delegable, and pretending it is, is how a clean diff with a wrong decision gets merged.
Stage 5: Debugging — won when the loop was closed, lost when it needed a hunch
Debugging split cleanly.When there's a closed feedback loop — a failing test, a stack trace, a reproducible error — the agent is excellent. It runs the test, reads the failure, forms a hypothesis, patches, re-runs. That loop is native to an agent with a terminal, and it'll grind through it faster and more patiently than I will.
When the bug needs a hunch — "it's slow but only in prod," "this only happens for users who signed up before the migration" — the agent flails. It needs the thing it doesn't have: the half-memory of a decision made eight months ago that never made it into the code. That's where a human who was there beats any amount of context window.
The rule: agents close loops; they don't form hunches. Give them the reproduction and they're great. Ask them to find the reproduction in a vague prod report and you're better off driving.
Stage 6: The boring glue — pure, unambiguous win
PR descriptions. Changelogs. Commit messages. Release notes. Backfilling docstrings. Writing the "why" comment I always skip.This is high-typing, low-judgment, and nobody's ego is attached to it. It is the least discussed stage and the one with the cleanest return. If you're going to put one agent in your workflow tomorrow, make it this one — zero risk, immediate time back, and it quietly makes everyone else's code more readable.
The rule: the safest, highest-ROI agent is the one writing the prose around your code, not the code.
The honest summary: the bottleneck moved, it didn't disappear
StageBeforeAfterDeciding what to buildsomemoreWriting the speclittlea lot moreTyping the codea lotlittleWriting testslittle (be honest)some — but reviewing themReviewing diffssomea lot moreThe boring gluealways skippeddone, automatically
If you chart my week before and after, the total didn't shrink much. What changed is where the time goes:
The agents genuinely won the typing. But every hour they gave me back on typing, they handed back as spec-writing and diff-reading — because those are the two places where their confident wrongness has to be caught by my judgment.That's not a complaint. It's the actual job now, and it's a better job. But it's a different one, and the people getting burned are the ones who think "the AI writes the code" means "the AI does the work." The code was never the work. It was the part that happened to look like the work.
What I'd actually tell you to do
- Start with the glue** (Stage 6). Zero risk, instant payoff, builds your trust in the tooling.
- Then the high-typing code** (Stage 2) — but only where you've already made the decision. Write the spec first, by hand.
- Split your test agent from your code agent** (Stage 3). This is the single highest-leverage structural choice in the whole setup.
- Keep the judgment review on a human.** Use a reviewer agent as a first pass, never as the last word.
- Read every diff like a stranger wrote it** — because one did, and it's a stranger that never gets tired and never says "I'm not sure about this part."
Disclosure: I build on xenition, a workspace assistant that builds and runs agents — so I ran a lot of this on our own agents against our own backlog. Read my "always keep a skeptic on the diff" stance as a builder's bias; I'd rather name it than hide it.
If you've moved part of your workflow onto agents: which stage held, and which one quietly burned you? I'm most interested in the stage you assumed was safe and wasn't.#ai #devops #discuss #webdev #software #coding #development #engineering #inclusive #community
I Replaced My Entire Dev Workflow With AI Agents — Here's What Actually Worked