gabby

violence is the first refuge of the dominant

beautiful women named "Series B startup in growth mode!" keep messaging me

Day002 😘

Late madohomu valentines on the off chance bluesky gives me greater mileage for once lol #pmmm #madokamagica #madohomu #魔法少女まどかマギカ

programmers are always posting like "worked on tracking down an issue with a Flurble deployment for twelve hours. the problem wasn't in Flurble at all - it was in the Gumbies install. It turns out if you install Gumbies 3.0 over Gumbies 2.7 and don't do a cache flush on all the client spiders they'll get stuck in the crystal maze." then you look up Gumbies and the site is one of those scroll scroll scroll types with one sentence per page, like "GUMBIES is a lean, expressive sharding sandcube for testing and deploying large scale Woodchips playgrounds. GUMBIES automates and streamlines away watersliding phases, meaning your team can get right to the chipping. See why Microsoft, OpenAI and Bloingo have embraced GUMBIES in their Woodchips workflows." and you get to the bottom and you're like I want this I guess but I still don't know what it is

Yeah, part of the reason why I care about the quality of the underlying process/code is because when it is bad then the cost (in tokens and in human engineering time) of creating a “correct-solution shaped hole” becomes enormous

Victory…? Floors Climbed: 48 Elites Killed: 8 Gold Gained: 888 Small Deck: 18 Well Fed: 17

finished my first slay the spire 2 run

yeah but that also suggests that the model’s understanding is not generalizing well if it underperforms that badly on a language of haskell’s size

This is why I don't believe when people say the agent did all the work. There is no way you can convince me that the people using these models to code aren't heavily babysitting the models (either with prompts or a giant repository of rules telling the model "please stop doing the stupid thing")

In case people are wondering, this is using Opus 4.6, their "latest and greatest" coding model

Do you see why I can't take agentic coding seriously?! Even when you slap on tool use and reasoning it's trying to come up with a valid solution by Brownian motion. No wonder it wastes so many tokens

when :: Bool -> IO () -> IO () when True m = m when False _ = return () unless :: Bool -> IO () -> IO () unless b = when (not b)

Claude I'm so proud of you for reimplementing these trivial utilities which already existed in `base`. I'm so proud that I'm going to hang these up on my fridge

(<|>) :: Maybe a -> Maybe a -> Maybe a Nothing <|> b = b a <|> _ = a -- Reuse Data.Maybe version instead: import Data.Maybe (fromMaybe)

Sometimes Claude gets it right and actually imports a function from `base` instead of reimplementing the function

Oops, wait, the `import` is in the middle of the code, which is not legal Haskell. Apparently Claude can't even get that right?

(<|>) :: Maybe a -> Maybe a -> Maybe a Nothing <|> b = b a <|> _ = a

Why did Claude do that? Because earlier Claude had actually reimplemented the `(<|>)` operator from the `base` package which conflicted with the original operator

Instead of using the `(<|>)` operator from the `base` package Claude "fixed" the error by reimplementing it as a named function … twice

-- | Left-biased Maybe: return the first Just, else the second. firstJust :: Maybe a -> Maybe a -> Maybe a firstJust (Just a) _ = Just a firstJust Nothing b = b -- | Prefer a non-Nothing value from two, taking the left firstJustM :: Maybe a -> Maybe a -> Maybe a firstJustM = firstJust

Claude defines a `firstJust` function, which already exists in Haskell's standard library (it's the `(<|>)` operator) and then for whatever reason defines a `firstJustM` synonym for the function within the same file. Why do you need two names for the same function within the same file?!?!

readTQueue :: TQueue a -> STM a readTQueue = Control.Concurrent.STM.readTQueue

Okay now this is just fucking stupid. Why are you creating an unqualified synonym for a qualified function of the exact same name. YOU COULD JUST IMPORT THE ORIGINAL FUNCTION UNQUALIFIED?!?!?!

A model should not require **any** context whatsoever to understand what is wrong with this line of code

readTVarIO :: TVar a -> IO a readTVarIO = atomically . readTVar

Claude, why the *fuck* are you reimplementing `readTVarIO` from Haskell's `stm` package. The package already exports a function with the exact same name and implementation that you can import. You are already importing other things from `Control.Concurrent.STM.TVar`!!!!!!

I cannot overstate how comically bad coding models are.

I was kicking the tires on Claude code while researching agentic coding for a blog post and couldn't help but notice numerous hilarious code fragments scroll past me while passively observing.

I'll mention a few in this thread …

instructions unclear. dick stuck in ember

my girl's tits, framed perfectly by her dress

my girl is _such_ a catch

noooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo

paying anthropic $200 each coding session because you've maxed out your claude code sub and are paying direct API prices is literally the vibe coding equivalent of being a whale in gacha games, btw

aaaaaaaaaaaaaaaaa i didn't realize today was the slay the spire 2 release day!!!

The spec is 1/6(!) the size of the code and the only reason it's not even higher because the spec omits details that the user would want to remain stable between codegen runs (like UI). Do you really think a user would be okay with the UI changing every time they request a bug fix or new feature?

### 10.2 Session Startup Handshake Reference: https://developers.openai.com/codex/app-server/ The client must send these protocol messages in order: Illustrative startup transcript (equivalent payload shapes are acceptable if they preserve the same semantics): ```json {"id":1,"method":"initialize","params":{"clientInfo":{"name":"symphony","version":"1.0"},"capabilities":{}}} {"method":"initialized","params":{}} {"id":2,"method":"thread/start","params":{"approvalPolicy":"<implementation-defined>","sandbox":"<implementation-defined>","cwd":"/abs/workspace"}} {"id":3,"method":"turn/start","params":{"threadId":"<thread-id>","input":[{"type":"text","text":"<rendered prompt-or-continuation-guidance>"}],"cwd":"/abs/workspace","title":"ABC-123: Example","approvalPolicy":"<implementation-defined>","sandboxPolicy":{"type":"<implementation-defined>"}}} ``` 1. `initialize` request - Params include: - `clientInfo` object (for example `{name, version}`) - `capabilities` object (may be empty) - If the targeted Codex app-server requires capability negotiation for dynamic tools, include the necessary capability flag(s) here. - Wait for response (`read_timeout_ms`) 2. `initialized` notification 3. `thread/start` request - Params include: - `approvalPolicy` = implementation-defined session approval policy value - `sandbox` = implementation-defined session sandbox value - `cwd` = absolute workspace path - If optional client-side tools are implemented, include their advertised tool specs using the protocol mechanism supported by the targeted Codex app-server version.

#### 4.1.1 Issue Normalized issue record used by orchestration, prompt rendering, and observability output. Fields: - `id` (string) - Stable tracker-internal ID. - `identifier` (string) - Human-readable ticket key (example: `ABC-123`). - `title` (string) - `description` (string or null) - `priority` (integer or null) - Lower numbers are higher priority in dispatch sorting. - `state` (string) - Current tracker state name. - `branch_name` (string or null) - Tracker-provided branch metadata if available. - `url` (string or null) - `labels` (list of strings) - Normalized to lowercase. - `blocked_by` (list of blocker refs) - Each blocker ref contains: - `id` (string or null) - `identifier` (string or null) - `state` (string or null) - `created_at` (timestamp or null) - `updated_at` (timestamp or null)

The "spec" is 2000+ lines of markdown which looks like this

This is not a spec. This is code that just happens to be stored in markdown form

*taps the sign*

"nice language! did your mom pick it out for you?"

"If you understand the problem space" is doing a lot of heavy lifting there

That is, like, the vast majority of the work in software engineering, especially as you become more senior, and the more you lean on the agent the more your understanding of the code and project atrophies

one of the reasons I'm so down on the current state of the AI industry is that I see so much potential in LLMs and I feel like that potential is being massively wasted, despite the amount of money being funneled into the industry

I 100% agree with this. Often checking an agent's output requires as much or more work than it would have required a human to do the work themselves. This is *especially* true for the most common users (junior/novice developers), where they are incapable of properly checking the agent's work