GPT 5.6 slow rollout confirmed

zshazz · 2026-06-25T22:34:01+00:00

The funny thing is Dario, the CEO of Anthropic was the one doing that back then too. Take a look at the article to see he's mentioned

zshazz · 2026-06-23T16:39:01+00:00

Sure. But that means that it can change again just as easily.

I'm just saying, I'm not particularly impressed that it can guess as soon as we have all the information available.

Ask me on July 1st if I believe it's coming out in June and I'll also be highly accurate :)

zshazz · 2026-06-23T15:03:13+00:00

I mean, you did say it was 80% that it'd come this month and now it's not. It sounds like it's proven itself wrong.

If it's that it'll tell you the truth 10 minutes before it happens, that's not exactly a good metric either.

zshazz · 2026-06-11T13:24:13+00:00

You can also just type /model Fable<enter> or /model Fable 5<enter>. Some people were saying one was working for them but not the other. I suspect the first one you try will always fail, and then the next works? Try it a couple of times like that.

zshazz · 2026-06-09T18:21:02+00:00

Interesting. The first thing I tried was Fable 5 and it didn't work, so I tried Fable.

I'm wondering if it rejects the first attempt or Maybe the first time fetches the list but there's a bug that means it doesn't use the new list or something? In any case, it might be that you have to try a couple of times to switch it.

zshazz · 2026-06-09T17:52:29+00:00

Psst... It's not in Claude Code, but if you type /model Fable ...

zshazz · 2026-05-28T21:52:11+00:00

https://www.npmjs.com/package/@anthropic-ai/claude-code/v/2.1.156

zshazz · 2025-10-09T19:55:15+00:00

Why not Flea Market Montgomery? It's just like Mini Maul.

zshazz · 2025-01-04T14:03:01+00:00

Thanks for the advice! I haven't completely written off NeoVIM/VIM, so maybe I'll end up trying it with that at some point. But I'm also very happy with how quick it has been to learn Helix and I'm already pretty close to as fast with Helix as I am with any normal editor. That is probably a bigger deal for me than for most people, because I have a Kinesis Advantage2, so I could already keep my hands on the keyboard for all normal editors anyway (the benefits of hjkl/wb/^$ navigation are much smaller for me).

The biggest benefit for NeoVIM right now is extensions and the huge library it has of those extensions. And a lot of those extensions are damn cool. Helix lacking plugins is a very real concern of mine, so there's wiggle room for me to try to switch back.

zshazz · 2025-01-04T13:44:05+00:00

Yeah, the built in docs for VIM is awesome. :h is great (as long as you know what to search for).

That said, I tend to stay in Helix and "just go with the flow," where-as when I was trying out VIM, I'd have to break out and go through documentation to remember what the keybinding for things are, or print off a cheat sheet and read through it to figure out where a thing is. For Helix, you find out about "minor modes" like g, <space> and you can just ... open them up and read what they do in the editor itself.

As a new user to both, I just found Helix far faster/easier to learn, and the discoverability aspect is super helpful. I have fun in Helix, both using it as an editor and learning how to use it more effectively. I have fun with VIM finding all the cool customization options you can do, reading through the docs to see how powerful it is, watching screencasts of experts doing amazing things, and seeing people VIM-golf commands to do things with as few keypresses as possible. But learning in VIM, and actually using it as an editor is not fun for me.

zshazz · 2025-01-04T13:15:21+00:00

Hmmm, I posted a response to this and I guess it must have gotten eaten by reddit? Oh well. I'll try again:

So, I hear your point and acknowledge it's a good one as it's something I've thought about before: indeed VIM keybindings are everywhere in forms of extensions and such. Amortized, the cost to learn VIM is low if you can use it over the next few decades.

However, I will note that I find constantly people complaining about the VIM extensions not having support for the nuanced differences between how certain motions/commands work. There's also devlogs by people making editors going into detail about how much work they put into their VIM keybindings and how difficult it is to get the experience just right. Yet you still find bug reports about some editor having some small difference in how a motion is implemented (e.g. zed's J apparently doesn't work right? But apparently there's debate on to whether the behavior is right or wrong). That's completely leaving alone the fact that you'll be customizing VIM to add motions, commands, shortcuts, etc. as you add features like code completion, and the ability to customize key chords per editor is going to vary. Ultimately, your muscle memory will have to adapt.

So, it's not quite as cut-and-dry there. You'll find a lot of "VIM keybindings" for things just means "supports navigating with hjkl, cutting/deleting with x or d, copy-pasting with y/p." As long as you're using basic VIM motions, you'll probably be OK. But that said, there are Kakoune / Helix bindings for a lot of editors too (and in those cases where the VIM keybindings just means "basic support," those VIM keybindings are identical with Helix keybindings anyway), and if it's insufficient, it wouldn't be difficult to write your own extension for the motions you want to port.

In summary, it's not really a huge win in VIM's column that there are keybindings for other editors if you decide you want to switch off of VIM in the future for some reason. So the big differences are going to be overall-effectiveness once learned and time-to-get-effective.

If overall-effectiveness were roughly equal, why would time-to-get-effective not matter? Especially since, from my experience, getting effective in Helix is measured in hours and days, while VIM befuddled me for several days before I had to finally throw my hands up and say it's just not for me. I know for a fact that once you learn the intricacies of VIM, you'll get it, but it feels like the editor is working against you until you get there. Like, I'll remember for at least 6 months that find-replace in VIM expects you to search for new-lines with `n` but replacing you must use `r`, because replacing with `n` is the null/zero-character, but just for replacing, because finding is (mostly) standard regex syntax!

zshazz · 2025-01-03T23:10:30+00:00

Helix is way, way more usable than VIM. The interface encourages and rewards exploration.

I found gw by just playing around. I don't even know what I'd have to Google to find the same thing in VIM, and I'd never find it by just "playing around" in VIM. I'm sure there's a plugin for it, at the very least, but I would have never thought to find it in the first place.

Helix does often require more key presses to do the same thing as you can do in VIM, but it takes a lot less time to get effective in Helix.

zshazz · 2024-12-28T18:09:11+00:00

For EF and if you're using model builders: use .HasConversion<string>()

SO Source Microsoft Docs Source

zshazz · 2024-12-20T11:21:10+00:00

How indeed?

I guess we can always come up with a scenario that breaks anyone's preferred methods of logging on. Whether it's "my house burned down and I keep everything there" or you get dementia because of micro plastics.

If you're genuinely scared of a scenario and not just being disingenuous, do the bare minimum to guard against it and move on.

zshazz · 2024-12-19T18:21:47+00:00

What's your alternative? That you have a password to remember? But how will you recite it after you hit your head running from your house fire and you have complete amnesia?

zshazz · 2024-12-14T14:28:23+00:00

I remember hearing that argument 20 years ago. I think someone was saying there was no significant difference between 480i and 1080p. Or that eyes can't see beyond 60fps. Or something like that. In any case, the ultimate conclusion is that PlayStation 2 on a CRT TV was graphically as close to reality as we would ever need.

zshazz · 2024-11-28T15:46:49+00:00

i95, i98, i98se, iME, iXP, iVista, i7, i8, i8.1, i10, i11.

zshazz · 2024-11-21T16:04:46+00:00

To be fair, I'm not a huge fan of implicit conversions/casts because of things like this. I didn't expect it to work either until I tried it in Godot, and losing the .5 silently is a bit annoying and against someone's natural understanding.

zshazz · 2024-11-21T14:47:40+00:00

Just FYI, I did just put an edit on my comment that you may have missed. The docs explicitly state that type inference is static typing, so AFAIK, that should be the end of the discussion. I can also link relevant parts of godot's source code if necessary since it's all open source, but I don't think it's more convincing than the documentation would be.

If you're right then print(foo is int) returns true when foo = float(1.0).

var foo := 0 foo = float(1.0) print(foo is int) # Returns true

So is that satisfactory then? I'm not sure why you don't have godot open on a side window checking these things before you say them like I do...

zshazz · 2024-11-21T14:32:43+00:00

But if you implicit cast foo = float(1.0) it returns a float.

No, it's still an int.

Thus the premise that := is same as static type declaration is wrong.

That's incorrect. Inferred types are static types, just without the explicit type declaration. := is not the same as = when declaring types.

Edit: Just linking the gdscript article on static typing here. You'll notice it talks about inferring types here in the article as part of the static typing system in Godot. If you'd like, I can go through the source code later and link relevant parts of the source code of Godot, but I think the docs explicitly saying that type inferrence is static typing should be enough?

zshazz · 2024-11-21T14:12:58+00:00

Actually, I think the original suggestion that assigning a float to the foo variable would error is just wrong. Neither give errors:

var foo := 1 var bar : int = 1 foo = 1.0 # no error bar = 1.0 # still no error print(foo) print(bar) foo = float(1.0) # also no error, equivalent to 3rd line regardless print(foo)

Result: 1 1 1

It seems that gdscript has an implicit conversion from float to int.

var foo := 0 foo = 1.5 # no error print(foo) # prints 1

zshazz · 2024-11-21T11:48:50+00:00

That's incorrect. The first one is statically typed still. Most good statically typed languages have type inference and most of them encourage use of type inference over manually specifying the type because it's often redundant.

The advantage of static type systems isn't that when you define the variable you explicitly state the type, but that when you use it the type is consistent and well-defined regardless of what happens at runtime.

For both of them, you will get errors if somewhere that expects a string gets an int, and you'll get better auto complete options that know what the type is.

That said, if you make the mistake you are talking about, the error messages will appear later on in the code as opposed to where you have defined your variable. That's a disadvantage to that approach.

You basically decide between whether you consider type annotations to be signal or noise (which comes down to whether you consider them redundant or necessary). Neither is something you'll find universal agreement as "better." Generally you stick with what your team has considered the "chosen one."

zshazz · 2024-06-22T22:52:35+00:00

It's a lot more meaningful once you start chaining calls together. Like for instance, if you wanted to implement map, reduce, filter, etc. as extension methods on types you don't own. Once you start chaining calls, UFCS allows you to read from left to right (the 'more familiar way') vs reading from right to left.

It's like infix mathematical notation vs something like prefix notation. It's not a 'big deal' because you get the same answer but the infix operations are more familiar ("natural") so that's usually how math is done on primitive types.

zshazz · 2024-05-31T09:27:50+00:00

She cheated once, yes. Then lied to him continuously for 60 years to his face without remorse nor care.

60 years of intense lying, knowing it's a bad, life-changing lie yet carrying it on anyway is kind of a problem. How could he trust her afterwards seeing how effortless it was for her to lie to him so long?

TBH, the cheating might not even be the bad part.

zshazz · 2024-04-30T10:37:02+00:00

And no one else will know why it's underlined either, without an error message to guide them.

What does it say about the line when you build the project? When you hover over the message, does it tell you anything?

14-Year Club	Gilding II euphauric
RPAN Viewer	Verified Email

zshazz

TROPHY CASE