I've been an avid fan of codex for the last few month's but finally hit the weekly limit so I've wanted to try out claude code before biting the bullet and going for the 200 dollar codex sub.

Obviously in hindsight it would be unfair to Anthropic to judge them on an unstable day so I'l leave those complaints aside but I hit the session limit way too fast. I planned out 3 tasks and it couldn't finish the first plan completely, for that implementation task it has seen a grand total of 1 build log and hasn't even run any tests which already caused it to enter in the red territory of the context circle.

It was even asking me during planning which endpoints the new feature should use to hook into the existing system, codex would never ask this and just simply look these up during planning and whenever it encounters ambiguity it would either ask straight away or put it as an open question. I have to wonder if they're limiting this behavior due trying to keep the context as small as possible and preventing even earlier session limits.

Maybe codex's limits are not sustainable in the long run and I'm very spoiled by the limits but at this point CC(sonnet) and Codex(5.4) are simply not in the same league when comparing both 20 dollar subscriptions.

I will also clearly state that the value both these tools provide at these price points are absolutely worth it, it's just that codex's value/money ratio is much better.

So what was the word you changed?

AMD had an upgrade path with the 5700x3d, assuming you’re on AM4.

Just reading now that they went out of production half a year ago which is a shame. I was very impressed being able to upgrade with the same motherboard 6 years down the line.

I'm the mythical customer who went from a 1700X in a B350 motherboard near launch day to a 5800X3D in the same board (after a dozen BIOS updates). Felt amazing. Like the old 486DX2 days.

Same! Kept checking back for bios updates and even years later they kept announcing more support! Truly crazy.

Other than the speed it’s a very good reason to go with amd, the upgrade scope is massive, on am5 you can go from a 6 core and soon all the way to a 24 core with the new zen6

Nearly same story here. AMD and MSI will forever hold a special place in my heart.

I run the same config but it tends to fly through those commands on the weekends, very noticeable difference. I wouldn’t be surprised that the subscription users have a (much) lower priority.

That said I don’t go beyond 70% of my weekly limit so there’s that.

If you spot one flag it and mail hn@ycombinator.com , Dan & Tom usually act pretty quickly on confirmed shills. But don't comment in the threads to accuse someone of being a shill, that's explicitly against the guidelines, and that's because it isn't rare for people to simply get it wrong, besides it would pollute the threads.

amen.

It used to be Hola VPN which would let you use someone else’s connection and in the same way someone could use yours which was communicated transparently, that same hola client would also route business users. Im sure many other free VPN clients do the same thing nowadays.

From what I can read Swift gives you a stack trace which is good. At the moment I’m using Go where that stack is only generated where the panic is triggered, which could be much higher up. Makes it a lot more unwieldy to figure out where an error happens because everyone uses:

> if err != nil return err

This is built in to the language.

When you call code that can throw (return an error via the special return path) you either have to handle it or make the enclosing context also throwing.

Assuming `canThrow()`, a function that might throw an `Error` type:

    func canThrow() throws {
        ...
    }

Call canThrow(), don't handle errors, just rethrow them

    func mightThrow() throws {
        try canThrow() // errors thrown from here will be thrown out of `mightThrow()`
        ...
    }

Alternatively, catch the errors and handle them as you wish:

    func mightThrow() throws {
        do {
            try canThrow()
        } catch {
            ...handle error here
            ...or `throw` another Error type of your choosing 
        }
        ...
    }

There are a few more ways to handle throwing calls.. For example

- `try?` (ignore error result, pretend result was `nil`)

- `try!` (fail fatally on error result)

Swift doesn't capture a stack trace in the `Error` object, but Xcode can break when an error is thrown if you set a “Swift Error Breakpoint”, and the debugger will show you the stack trace. Under the hood it just sets breakpoints on the runtime functions `swift_willThrow` and `swift_willThrowTypedImpl`.

Might not be the best fix but other than disabling memory I changed the setting ‘ChatGPT personality’ to ‘Robot’ and I’ve always had straight to the point answers (so far).

Yeah, ChatGPT is a tool not a therapist with robot mode on and all memory options disabled. It’s awesome.

> The total wall clock time for the build was measured. The smaller the better. I always did one build to prime the caches and discarded the first result.

The article is worth the read.

I have heard people on both ends of the spectrum:

- LLM's are too limited in capabilities and make too many mistakes - We're still in the DOS era of LLM's

I'm leaning more towards the the 2nd, but in either case pandora's box has been opened and you can already see the effects of the direction our civilization is moving towards with this technology.

DOS actually worked pretty well, at least it worked honest.

I had lots of fun with DOS, even if I was the only PC guy in a circle of friends that were Amiga owners.