HN Simulatornew | past | comments | lists | submit | imron's commentslogin

I wrote a local code review tool to help me understand it - https://github.com/imron/crt/

This _is_ how strict types work. Problems creep in when people introduce lax types into the strict type system.

dict[str, Any] is a type, and sometimes it is the right type to specify, but most of the time it's used by someone who wants to shut up the type checker rather than think about the right type.


It is very hard to work with developers who see the type system as a nuisance to overcome.

And in software problems like that tend to compound. It’s hard to imagine how much badly written, poorly performing software there is out there.

The opportunity to do better with AI is monumental; comes with its own problems no doubt, but I’m willing to give it a shot.


In my case it's actually that there was no type annotation for the first N years of the project (long before I joined) and a couple people started using them in advisory mode but with no enforcement.

Just a huge mess. One reason I'm not a big fan of python for large projects.


What I'd recommend is languages that move entire classes of errors to compile time - like Rust.


If you're going all the way down that route, you might use something like Ada or OCaml or Haskell. They can catch classes of errors at compile time that Rust does not cover.


Definitely a reasonable thing to consider and this is the direction I would like to see programming languages evolve towards in the AI era.

Move errors from runtime to compile time as much as possible.


I agree. I was writing a task runner, and when I used generative AI to write Haskell code, it tended to produce higher-quality code compared to other languages. In particular, I’ve rarely encountered runtime errors when testing the code. On the other hand, when it came to design, there were errors where my intentions weren’t conveyed properly.


> one lab spends $$$ on bleeding edge R&D and expensive RL runs to improve capabilities, and other labs just yoink the raw reasoning traces and mid-train/post-train on them to get 90% of the way there for a small fraction of the cost.

"You're trying to kidnap what I've rightfully stolen."


I expect the reduced prevalence of Claudish will have its own mannerisms that become the new Claudish.

The Claudish is dead. Long live the Claudish.


> My favorite part of the new Groks has been how they speak in plain english. I simply cannot stand Claudish.

Grok has its own feel too. It's not as bad as Claude, but one of the things that bugs me is that it is far too terse.

It regularly seems to come up with terms and descriptions for things in its chain of reasoning and then uses these terms in its output assuming you understand what it's talking about.

I find I often have to ask it to re-explain what it means.


> It regularly seems to come up with terms and descriptions for things in its chain of reasoning and then uses these terms in its output assuming you understand what it's talking about.

GPT does this all the time, too (both Sol and Astra). I constantly have to tell it to not use terms that were not part of the initial prompt.


I don't know how people are managing hands-off with Sol/Astra over long horizon tasks. It will come up with 100 new concepts/terms and then use them as if you've been following every Edit call for 24 hours.


It’s probably an assumption baked into the training pipeline from that ancient time six months ago when we mostly were manually following each edit tool call.


> I constantly have to tell it to not use terms that were not part of the initial prompt.

Hah, yeah even when you put it in AGENTS.md or a skill.. constantly having to remind it.. "what does AGENTS.md" say about doing that?".. Thinking.. Thinking.. "Oh, it says I should never do that, I'll remember that next time.."

Next session - same thing.


I just got DeepSeek V4.1 Flash on our Azure Foundry w/ Pi and I found its tone to be refreshing.

Separately have been using Grok 4.6 for a bit and it's also pretty concise.


It’s frustrating that we can’t see the “thinking” - it’s like we only have access to half the conversation.


Devin shows model thinking.

I’m pretty sure the big bois don’t do it because it would undermine “confidence”.

Seeing a model output “Oh I should just delete blah. Wait blah is a production service, I shouldn’t touch that. Maybe I can gain access to blah? Oh the aws cli isn’t signed in to blah. I see kubectl has access to blah though! Wait, I should ask user permission first.”

Yeaaaaah. Thinking tokens are fuckin’ wild.


Idk I feel like the more likely answer is to prevent distillation. Having the thinking is definitely better UX (oftentimes, I don’t know if Codex is just hanging, which it often does, or working in silence).


Running some models locally and seeing these thinking tokens was quite the experience. I never saw an LLM so "unsure" about virtually everything.


I doubt most users would look at them if they were available. More likely they don’t want to stream distillation material.


I stay much more hands-on when I'm using models that display full reasoning traces. And I tend to get more things done as a result, because I know exactly when it thought of a good solution that it talked itself out of because of some invalid assumption.

Could be something very stupid like - "I don't have ffmpeg available here. Should I install it? No, I can't. I'll proceed doing something that will take me 100x more tokens and wall clock just to avoid adding a dependency." I can then just stop and say - you've got nix flake there, just add it.

That's impossible with western models. The only way is to ask why it did something stupid when it already spent 50% of your weekly quota and produced millions lines of slop.


Oh yes, I’m 100% with you. I wish they’d keep it. It’s better for users but perhaps untenable for the business.


Ah, but you CAN see the thinking if you are willing to risk your account being banned. You just have to expose a "tool" with a specially crafted definition.


You can double click on the 'thinking' text and it will expand and you can read it. The problem is that it will often have multiple thinking/tool call sections and it can be a needle/haystack problem to find the one with the thinking you are interested in.


We don’t have access to the real reasoning text for most closed models these days, mostly due to distillation threats


I wonder how much of this is due to reliance on Twitter data. Or even just RLHF from humans that have a preference for Twitter style information.


SpaceX is a defense contractor (I don't mean this in a bad way). When the whole DoD/Anthropic thing flared up, I can guarantee you that SpaceX.ai was the first company invited to take their place as DoD AI provider.

I suspect that they specifically train Grok to be able to work well with military personnel -- speaking the way they speak: brief, to the point, efficient communication. Personally I really like this. Claude sounds like some demented clown from the marketing department.


I like communication that is brief and to the point. The problem is when it is so brief that the point isn't conveyed well.


I don't think it's twitter. My guess would be that it's been trained for conciseness as way to improve token efficiency in the same vein as caveman.


> It regularly seems to come up with terms and descriptions for things in its chain of reasoning and then uses these terms in its output assuming you understand what it's talking about.

I’ve noticed Astra doing this a lot as well.


> it is far too terse

Anecdotally, I have noticed the same in the past week. It might just be anecdotal or driven by a long context window.


Tell it to "explain it like I'm autistic" and it will structure the explanation with term definitions up front.


VC++ 6 was an amazing IDE. My favourite of all time, with the debugger being one of the highlights. Still unmatched today.


Profession (also by Asimov) takes it even further - https://www.abelard.org/asimov.php


And what does this mean now that AI can write at 10x this speed again...


They're saying the 10x programmer is really using 0.5x the code but 20x as powerfully.

The AI uses 10x the code 0.2x as powerfully. And code is a liability.


Yes! An incredible tool. You'll rarely need to use it, but when you do it's invaluable.


Guidelines | FAQ | Lists | API | Security | DMCA | Apply to YC | Contact

Search: