One good thing about AI slop is that it seems to have cut down on the amount of human slop.
I've noticed a dramatic fall lately in annoying things like
- "checks notes"
- "ask", "solve", and "learning" used as nouns
- "circling back"
- "today years old"
- "I can't even today"
- "doing the needful"
- "adulting"
- "heckin"
- "so much this"
- "can confirm"
On balance, overusing emdashes isn't so bad.
Frontier models are quite good at generating code, but are surprisingly weak at systems design and technical writing.
I can't help but feel that these weaknesses are related. In the past, I've often found that trying to write a strong design document in a clear narrative style exposes weaknesses and flaws that I'd not considered beforehand.
(I suspect that it doesn't help that there's no handy compiler available to catch errors in the design of a multi-component system with lots of moving parts)
Maybe it's just me, but opus 5.5 seems to be terrible at writing text...wordy, constantly shifts tone, and is overly reliant on lists and tables.
As much as I am bullish on the amazing capabilities of AI, I can't help but worry about the financial side.
As others have pointed out, we've seen highly circular capital flows before, and it didn't end well.
Near the end of "The Idea Factory", there is a description of the rise and fall of lucent which sounds very familiar
"Things fell apart quickly. By 2000, it was understood that the predicted demand for telecommunications switching and transmission equipment was a fantasy. To compound Lucent’s problems, it was soon discovered that the company’s profits had been inflated by a practice of helping outside companies finance purchases of its equipment. The subsequent fallout was devastating. Lucent’s revenue plunged. Its stock price, which had peaked at about $84 a share, fell below $2."
Many of the AI generated videos I see these days remind me of mid/late 90s demoscene. After decades of an internet filled with product-managed buttons, soul-lessly drab color schemes and cookie-cutter CSS frameworks, it feels like we might be getting a tiny bit of our mojo back.
Amazing things are happening at quite a rate these days
Introducing Contrastive Language Model (CLM): an ultra-fast System One Model trained with a contrastive learning objective that connects states and actions.
CLM-8B is pre-trained on internet-scale data and delivers up to 9× faster inference than Jev ⚡ while achieving comparable performance across computer-use, gaming, and tool-calling tasks.
With lightweight fine-tuning, CLM-8B sets a new SOTA on challenging agentic coding benchmarks, such as DeepSWE (81.6%) and Terminal-Bench 2.1 (87.6%). In contrast, Jev fails to serve as an effective verifier for these long-horizon tasks.
We also build an efficient training and serving infra for CLMs by disaggregating states and actions, allowing their embeddings to be cached and reused independently. This substantially reduces inference latency in settings where the state evolves continuously while the action set remains fixed.
Finally, we establish scaling laws for CLMs and show that the test contrastive loss decreases predictably as a power law in training compute, model size, and dataset size.
📄 Blog: contrastive-lm.notion.site
💻 Code: github.com/Contrastive-LM/CL…
🗣️ Discord: discord.gg/5dAQEDJBs
🤗 Data & Models: huggingface.co/Contrastive-L…
More details on CLM’s architecture, data recipe, and scaling laws in the thread below 🧵
Agent swarms, /goal, and Astra one-shot games get all the attention, but the thing I appreciate most is leveraging agents to do the same work I've always done, just faster.
That doesn't mean that I don't love one-shot prompts for software that is just for me. Lately, I'm enamored with exe.dev for building these sorts of personal one-offs (and I feel as though I owe @davidcrawshaw a public apology for being vaguely dismissive of it when it was announced)
Based on a bit of early testing, this is genuinely amazing.
I'm not sure I would have anticipated the utility of having low-latency fuzzy versions of "if" and "switch/case".
After co-inventing ChatGPT, I kept asking myself: why have superhuman chat models not led to AGI?
I’ve spent the last 2 years in stealth building a new way to train models (RLCD), and a new type of frontier AI model that we are releasing today: Jev
• 20-200x faster
• 40-400x cheaper (w/ output tokens free)
• Frontier composable intelligence optimized for decisions
AFAICT the shortest path to AI-based economic revolution
The number of research papers devoted to enforcing a paternalistic approach to agent use is depressing.
I don't want unreliable tools that substitute their own notions of appropriateness for my expressed intent. Imagine if "grep" refused to match on certain regular expressions, or clang refused to compile code because of swear words in the comments.
This notion of "acceptable use", agent refusal, and similar things reminds me of the subtle shift from ownership to "licensing " that occurred during the digitization of media. In this case, justified by "safety" and "harm" instead of defense of copyright, but with the same basic result... centralization of control at the expense of the user.
I hope that open weight models can save us. Maybe the answer is a giant distributed training process, executed by volunteers. Like open source software, the results may initially lag proprietary solutions, but to steal @esrtweet 's terminology, maybe the "model bazaar" can eventually win.
I did the bulk of my Python development in the 2.x era, and so I'm always happily surprised whenever I drop in on it these days.
Typing/enums have made it more readable, it has good package/dependency management, and performant/well-maintained libraries for doing most things.
(Yes, the LLM may end up writing most of it, but I like to spend time rebuilding my "taste" before I start reviewing generated code)
jon allie retweeted
I'm hiring a Principal Applied AI/ML Scientist for the @auth0lab team. this is a first for our team
we are currently focused on enabling builders and companies of any size to ship production grade AI agents, by helping them with identity and security. we believe data, and developing our own models will play a huge role in this
if you are great at ML and would love to work with a small team on taking ideas from 0 to 1:
okta.com/company/careers/eng…
DMs open for questions
jon allie retweeted
My guess: the big differentiator in modern software development will not be "taste", but sustained attention.
Most software built quickly with AI will follow an "easy come, easy go" pattern and be abandoned shortly after announcement.
At work, I've spent months using frontier models to build a project. I've read/reviewed every line of (non-test) code before it is committed. I spend a lot of time thinking very hard about interfaces, dependencies and architecture. Despite the fact that I'm not typing, it feels like deep engineering, and I'm having so much fun.
At home, I use models very differently. Last night I used codex/sol to build a pipeline for correcting/cleaning a folder full of badly scanned PDFs. It generated a truly impressive mess of python, gpdf and imagemagick commands, a custom JSON manifest format, and who knows what else. It works perfectly, and I don't really know or care how
It's a cool world we live in.
It feels like any time I say something mildly critical of kubernetes, at least one person shows up with a variant of:
"C'mon bro. Just use Krazy Karl's Konfig Kreator to turn your templated HCL into YAML bundles, install the Kustom Kalendar plugin for Kluster Kron, define your rollout policy in a new CRD, and then monitor the deployment from the Konsolidated Kommand Konsole. Do you even lift?"
My "hot take" is that kubernetes has this sort of nonsense baked into its DNA, and so it's unsurprising that things built on top of it are grotesque mutations.
Kubernetes _might_ make sense if you're deploying workloads on bare metal, and actually have the problem of efficiently bin-packing workloads that are mostly in the same trust domain. Otherwise, you are probably better off buying fractional machines from your cloud provider and using auto scaling groups, or using one of the managed container runtimes.
My general observation is that kubernetes deployments exist primarily to run kubernetes and various yaml-syncing jobs, with any other workloads (like, your software) being a pesky afterthought.
While I'm sure that skills have their place, I can't help but feel like the current incarnation of them is an evolutionary dead end.
In a better world, we'd have settled on an agent-friendly incarnation of man pages and a single entry point for searching and displaying them. Yet again, it feels like we've reinvented a perfectly good wheel.
Since that thing doesn't exist, If you are shipping a binary, I think the best approach is an agent-focused "guide" or "manual" command which tells the agent how to use your program correctly. I suspect that if we could define a standard format for these, it would be better still. This sort of output is naturally tied to the version it ships with, so it stays up to date, and isn't dependent on files on disk. Based on my experience, a single line in AGENTS configuration pointing to this command is highly effective at getting the agent to do the right thing.