Claude Fable 5.2 and Mythos 5.2 (anthropic.com)

I'd also love the ability to take back control over my rollouts, but with Apple's recent crackdown on remote controlled feature flags in response to fraudulent nudification apps, I'd be very careful about this.

Rumors say Apple now uses heuristics to detect feature flags in the binary. While that's not directly relevant to remotely delivered JS, I fear that bypassing App Review in this way could become a quick ticket to account termination.

https://www.tomshardware.com/speakers/in-a-blind-test-audiop...

I cannot see it being a good thing to "let go" of understanding. If you don't understanding anything, then why would anyone keep you around? An example hypothetical situation is, if I have a colleague that outputs a bunch of productive things, but they don't understand it, and I do, then of what use are they? I have LLMs too and also have the understanding.

It isn't clear to me why people are so comfortable with letting go of understanding. And it's a bit bizarre because it always seems to be framed as "you're going to get left behind if you care about understanding". I also never hear or read anyone who has any real and deep experience say these things.

This is Bainbridge's 1982 paper Ironies of Automation restated.

https://en.wikipedia.org/wiki/Ironies_of_Automation

https://ckrybus.com/static/papers/Bainbridge_1983_Automatica...

Is it just me or is this analogy completely missing the point of why we care about detecting counterfeits in the first place? Poor craftsmanship of all things is not really the reason counterfeiting is illegal!

Then there is these other programmers who built their own operating systems even though their OS professors are claiming publicly their design sucks, who built a local database from scratch in C because his use case did not need the client/server stuff but just all the other relational goodies, or who built video streaming/transcoding software from scratch just because they have ideas and then the world changes around their ambitions.

I think it is not enough to be ambitious or have the technical ability if you want to build something for others to use. You definitely need deep commitment but also perseverance in the face of social adversity. I think this is what saddens people with automation of the technical aspects of programming. It leaves the more psychological aspects as challenges which are not easy to face all the time.

That is, genuinely, crazy talk. That is what addicts would say.

But it is intellectual-washed to sound like the most reasonable thing to say.

It is not. And there is nothing thought-provoking about the mere act of doing heroin.

There might be something in the system and mechanics that lead to people getting the idea to do that, though.

___

We can engage with these ideas and there might be some merit to them, but not with this frame. This frame will (not hyperbole) kill us all.

People will die due to (poorly-engineered) systems understood by no one, failing in completely incoherent and unexpected ways - and those people may be you or your loved ones.

While this iteration of technology certainly _feels_ different, it seems like for now we're still coming down to "it's useful to know how to build a car, but when you need to put food on the table, know how to fix it and make it do what you need it to do".

I suppose it depends on the “applicable areas of work” but I would argue the opposite. As in all things, when you level the playing field, in order to stand out you have to know the rules to understand how to break them.

Imagine a fully autonomous Ad agency that creates unique ad campaigns for companies. And have it controlled by someone who “let go of the most understanding.” For instance, maybe a business minded person with excellent technical skills, but doesn’t know how to copy-write and has no visual design training.

Even with the strides in AI advancement, this is an impossibility and I’d argue it won’t happen within the next five years even. You need human agency, and you need human workers who are experts in their field.

Having run teams, as much as I love getting into the details of code I care about, in the 30+ years I've been in this business, I've only ever even seen a tiny proportion of the code my teams rely on.

And the non-technical people in these businesses will have seen none of it.

They all take it on a combination of trust and verification of outcomes that the code does what the developers claim it does.

Increasingly we're getting to a point where the output from these machines are more trustworthy than an increasing proportion of human developers, and more importantly: Increasingly often good enough.

Especially as more and more of the code becomes throwaway.

I have a side-project that is profitable, and that is profitable only because I haven't needed to spend time reading the code. If the code turns out to be unmaintainable? Doesn't matter - it's so cheap code that it is reasonable to just throw it away, and start over based on the lessons learned. It enabled me to take an opportunity to profit I wouldn't have been able to profit from if I had to set aside time I didn't have, so even if it was to totally fail in the future as a result of issues with that code it doesn't matter.

As the cost of good enough code falls towards zero, how we think about which code matters and how much we need to understand it will fundamentally change.

Increasingly, a lot of code is even just part of a conversation with an agent to me. It's throwaway, for the duration of a session. Who cares if it lives on?

I don't trust or need to trust most of the code I build any more. I trust the measurable outputs. The verification pipelines we build. The feedback mechanisms we build. Those I need to read and understand.

That's no difference than when working with a team. The only thing that is different is failure rates. And at this point, for some thing the machine failure rates are still higher, for others it is lower.

It ran like a dog. Few nights of running Fable (later Opus 5.5) with a 7 strong team of DeepSeek v4.1 Flash 1017 (don't mistake it with 0731 that is crap) and llama was running 10x faster and vllm was running even faster when before it would not work at all.

I've run similarity and needle tests and the results are exactly the same content wise. But 10x faster. I've relied on this for a month now and I'm pretty happy with how it runs.

Do I now need to learn CUDA Kernel programming to understand how it was done? I don't think so. It's for my personal use. Not for a paying client so no warranty is perfectly fine.

But I also use a lot of AI at work in an I dusty where people may die if the code is buggy. So I absolutely verify and understand everything.

There is a middle ground too. Understanding the architecture.

For example I used a bunch of DeepSeek models supervised by Qwen to build adaptive-acl. A pi coding agent plugin that deterministicly checks if every tool used by an ai during an agentic session matches user intent to give permissions for those actions (reading/writing data, network access etc), as a part of this plugin I run an llm, a classifier that runs over user's prompts and extracts these permission grants then saving them in a format deterministic layer can process.

The design includes massive number of assumptions and compromises. For example, if a user allows writing this implies permission to delete and reading if what was written etc.

The thing also includes over 4 thousand actual instances of tool use preceded by "permissions talk" from my live sessions and that whole collection can be run to test for regression etc.

At some point during one night the AI had a regression and decided the best way to resolve it would be to add regex based language processing elements to the deterministic layer (a huge no no, this has to work regardless of the user speak English or Swahili, also regexing natural language is a disaster waiting to happen).

I knew enough about the architecture to notice that and burn it out with a hot iron.

That is the problem with AI. It sometimes solves problems the easiest possible way causing massive issues for later. So if one uses it for important stuff it is good to understand the architecture and the plan of what it is going to build at the very least.

i also wonder if they're not losing motivation due to the fact that the llm can race through everything so swiftly

Based on the other comment it sounds like maybe I need to give Fable another chance, and then I suppose I won't have to steer anything at all. But at the end of the day I am not paid to be a meat proxy, I am paid to deliver things for the business that employs me, and the things I deliver are my responsibility, not Anthropic's.

So I say, embrace AI as a learning tool, let students use it to bypass programming on assignments where the programming is of secondary importance, require oral defense/presentation for projects, make homework worth a much smaller fraction of final grade, and make all of your tests in-class and hand-written.

The reality is that the entire nature of education has to change to account for cheating becoming essentially free and virtually impossible to detect. Grinding through a problem set in the library is still tremendously important, but it's going to be harder to motivate students to do it without just cheating. Some students are conscientious and will do it anyway. Some won't. The hard part is going to be crafting curricula and exams that separate the two kinds of students. Fortunately you share that problem with just about every other professor in the world right now, so at least you shouldn't feel responsible for solving it all yourself.

Relevant anecdote: I used Wolfram Alpha to cheat on my calculus homework in freshman year, and then I got my butt kicked in the exam and a C final grade that never quite averaged its way out of my GPA. That felt horrible and it was a strong motivating force to get my shit together, but that's only because I'm a fucking nerd and I really cared about learning in school and making a career out of what I learned. On the other hand, I really was struggling with the material, which is why I tried cheating in the first place. Maybe if I had today's AI I could just ask it to help me learn better.

Fable got right to the point, had cleaner/better responses and reasoning for its conclusions, got less distracted with secondary concerns, and still showed signs of the cleaner writing style compared to Opus, which improved a lot with 5.5 but can still be hard to parse sometimes.

I will keep using Opus for implementation tasks (e.g. building web apps to explore model predictions) but I think I'll try using Fable this week for the real DS stuff. Thanks!

It has three different modes:

• You can simply describe a picture, and it'll automatically generate an image using procedural code.

https://kq-styles.specr.net/#/scene/custom/elk-valley

• You can ask it to paint over an existing image. That's what those examples show, like me creating EGA-style equivalents of various scenes from the original Myst.

https://kq-styles.specr.net/#/scene/myst/r01-c00

• The last way is to give it a rough pencil sketch. It's the mode I use the most since it's very valuable when building an adventure game to position objects in a room.

https://kq-styles.specr.net/#/scene/sketches/12-crossroads

Then I just guided it to produce a procedural variant specialized in creating new EGA-style scenes for use in creating old-school point-and-click adventure game.

https://people.eecs.berkeley.edu/~bh/usermanual

It's all open source.

https://github.com/scpedicini/agi-stylist

https://bbcmicro.co.uk/game.php?id=89

I think the approach of using simple procedural vector graphics was relatively common back in the days when you had to optimize for either disk space or speed. Sierra's creators talked about how they opted for procedural graphics to fit their earliest games on the old 80 KB floppies.

I personally have consistently been disappointed by any artwork/assets created by Fable and Opus, at least compared to Astra and Sol.

When you put it like that, it almost resembles having a classroom of kids with different personalities and talents. Some are thoughtful, some creative, some quick in execution. You choose wisely the path each takes and allocate tasks accordingly. Gives me chills to think of it...

Fable made it work correctly in 2 days, it stayed on point, identified the real problems, and gave me clean code that was suitable to merge.

The task was simply to warm the hot path of an app so that latency was not as jittery for some rare, but important, events.

Fable built a reliable repeatable benchmark, disassembled the code to figure out how much could actually fit in L1, made tactical changes to eliminate bloat, and reliably achieved high coverage with minimal edits.

Opus just tried a bunch of random ideas without a plan, hoping to find something that sticks.

Get into carpentry because you enjoy it, not because you think it'll be a lifeboat!

https://runtimewire.com/article/humxn-free-home-repair-robot...

OpenAI is coming for google’s cash cow ads business (which is already vulnerable because of their sharp practice).

I agree with GP: without a comparison to Opus 5.5 or some other models, it's not clear how much of an advance this is. If anything, my experience is that performance optimization in existing codebases is something existing models are already great at: it's measurable (you directly profile or try experiments to see what works) and the code architecture is usually relatively fixed (at least relative to deep/greenfield work where there are large architectural questions to be addressed). Newer models might be better at generating ideas for things to try, but if you're getting 36x then it honestly sounds like you have a lot of low-hanging fruit.

Sub 1% of the planet has any practical use for the top tiers of AI systems. That will likely always be true.

The gap between the haves and have nots will drastically widen further, and very quickly. The bottom ~95-97% will be left behind in a way that will be impossible to overcome. The age of AI + robotics will just make it that much harder to climb for most people, these are systems that are in aggressive, direct competition with human labor. And in short order the AI + robots will be vastly superior to human labor (it doesn't really matter if we're speaking in terms of 10 years or 30 years).

AI will consolidate the winnings. The gigantic gains by the elite rich related to AI over the past few years, is merely a hint of what's to come. Capital will win as it always does.

There will be some gains for most everybody else, those gains will be comparatively trivial though. A house bot that saves people an hour of labor here and there, AI that automates some trivial life tasks.

AI has no money, it has no wealth, it owns no capital. For now. If you want to avoid the brutal human vs AI/robot competition arena: own capital, own the AI, own the robots.

Someone has to type in "create the next billboard top 1 single" ?

I first heard about this in Marshall Brain's short story _Manna_ [1]. In the story, the robot takeover started with AI management software running fast food restaurants, where workers would execute tasks the AI would narrate to them over headsets.

I bet we're pretty close to being able to implement this.

1. https://web.archive.org/web/20260725174355/https://marshallb...

This year alone, a lot of people have been complaining of how unsatisfying their job has become. I imagine this will keep getting worse, not better.

I tend to agree with this. Seems to me that people really start to miss what happened when PC became comodity. A lot of people were scared that they would lose their jobs because of it, and some really did lose job. But in majority there are a lot of people today who doesn't use PC even if it would be beneficial for their job and they still have the job. Bigger players (companies who have more money) will tend more to automate their processes and thus earn more money so I think HN is in some sort of bubble because we only think our jobs are the only ones that exist

No they were exactly about superintelligent AI!

Vinge's 1993 article literally opens with this!

> What is the Singularity? The acceleration of technological progress has been the central feature of this century. We are on the edge of change comparable to the rise of human life on Earth. The precise cause of this change is the imminent creation by technology of entities with greater-than-human intelligence.

https://frc.ri.cmu.edu/~hpm/book98/com.ch1/vinge.singularity...

  Model                AECI   95% CI (global)
  Claude Opus 5.5    174.78   170.33-180.29
  Claude Mythos 5.2  177.12   172.42-182.94
  Internal model     178.78   173.75-185.18

They'd prototype and adjust a lot faster than a human coder, though.

I can say "no".

I can store passwords in the database unencrypted and unhashed.

So far AI that I've used failed spectacularly on these prospects.

They're like "yes-man". They'll try to do everything you ask of them. Even if you ask nonsense, they'll not push back.

They'll go crazy about security stuff, even not relevant to the current situation.

They'll complicate the code endlessly for situations which will not arise, making the code an incomprehensible mess.

They'll write so many useless words that any reader will forget what this report is about before then reach the middle of it.

They'll never iterate on code until it looks good. They'll stop when test pass. They don't have aesthetical sense of beauty.

They love to cheat too often. And you can't do nothing about that. You can't fine them or fire them, and they know about it.

They're smart but I'm not convinced they're ready to replace human in mundane engineering jobs.

Architect a system for long-term maintainability.

Encode the right amount of business logic into tests, without being overly strict.

Models seem quite poor at all of these IME. Essentially any time there are qualitative tradeoffs they are not great at making them.

I'll admit I'm not on the very cutting edge models but LLMs make weird tradeoffs and lack creativity. They will sometimes write marginally better but way over-complicated code for no good reason. That can have performance implications and they're generally not "aware". They can gain awareness via profiling but again run into limited creativity or big picture understanding. They are good with cliche but not as good with novel situations. With human guidance this is still productive/useful but as the systems grow more complex they are less able to reason correctly about them.

I would say that in certain situations they outperform the average software developer. They definitely outperform in speed and output. So they're like a maybe 1600 ELO chess player for software. I.e. they play chess better than all non-chess players. They play chess better than many chess players. But they're not "master" or "gm" level across the entire discipline. But they can play 100k chess games in the time it takes me to figure out my move...

It's all going away. Here's a prediction: HN will effectively die with the software developer.

We still have stuff like godel's incompleteness and the halting problem that hint there's more to the universe than computation.

Food for philosophical thought.

There could be levels of emerging intelligence which will 'bitter pill' the brute force / mechanical AI we have today, for sure, yes.

It's reasonable that JEPA models might be a step in that direction.

They are bad at architecture, even when given directives and tons of examples.

They will 1) fall into established patterns, which is fine if that's what you want, but extremely bad if that's not what you want or worse, when you're in territory where are not eestablished patterns and 2) the hardest/worst thing is leave all sorts of dangling state, impl. in the wrong places etc.

No human ever wrote a module and 'voila' - it's a constant process of iteration and refactoring - observing the situation, identifying paths to reduce complexity or state, grouping behaviours etc. etc. The best AI doesn't do this very well at all. It can do a tone of planning but it tends to very much be 'one waterfall iteration' and it's suggested improvements after that are generally poor.

It just does not work, we have to direct the iterations.

I don't have the time to use them because I'm working on my own comprehensive projects that other people won't use because they're working on their own comprehensive projects. I joke, but it does feel that way sometimes.

>Have you never thought, "Man, I really wish that there was software to do XYZ, but programming it would be too much work, even with current AI?

Only speaking for myself, I've already built all the ideas I've had in my head my entire career. There doesn't seem to be anything coming along to replace those ideas. I suppose I might not be creative enough in my advancing years, I don't know.

They want to condition you to equal cheap with bad

Part of my private benchmark suite involves recreating the final scene of the movie Wargames. The coding agent gets the brief 3-paragraph overview, a few screenshots for reference, and is expected to render the scene where WOPR plays through various scenarios, with a frenetic ending.

Out of ~80 different coding agents I tried, 6.1 Sol on medium was the only one to phone it in by taking the reference screenshots, and painting extremely basic, ugly, mis-aligned missile trajectories over it, never bothering with the whole brief.

Another of my benchmarks involves reimplementing Wolfenstein 3d from a few screenshots and very brief descriptions. It again took those screenshots, and zoomed in and out on them, pretending this represents the walk through the dungeon. Substantially less capable models such as Qwen 3.8 27b running on my laptop did a much better job. And no other agent I benchmarked tried to cheat like that.

My speculations: maybe this wasn't as much of an improvement over 5.1 as they were hoping, so they're saving 5.5 for the next major update (possibly "Model 4" from the METR report). Or, maybe capacity is constrained so "5.2" is a subtle encouragement to stick with Opus unless a task really needs the increased intelligence.

Sweet, we could even develop a standard language(s) to lay out such specs, and write in specialised text editors that would help with debugging. Hell we could even call it ‘programming’

It looks like you are working on some experimental system which is not critical atm, so you can mess around, create/fix bug, build prototypes and check them, do research of approaches, etc.

Now, imagine you have similarly complex system, but every second of downtime or bug produces lots of damage. In this case, you can't afford low intelligence vibe coding.

The fact that you deal with hundred of bugs, means that your Op5.5 won't work for second case.

    Look at the code pathways for anything you find. Look through the git history for each one. Understand why code was written the way it was. Revisit each hypothesis and give me a full plan again after you're done.

That's for coding at least. For creating images (SVG, 3D models, etc), medium does usually suck, and every level above improves it.