Fr0styMatt88

The Shield is dead though and a long-time abandoned, right?

I remember the Shield going from fantastic to a horrible mess software wise over the span of a single Android generation (maybe 2019 or 2020), constant ARC weirdness, etc.

Hahahaha the first time I tried to get into a Tesla and couldn’t figure out how to open the doors from the outside.

What do you mean about Steam?

I feel like wide screens and ultra-wide screens are massively under-utilised in UX design and there’s a lot of untapped potential there.

Ha I feel like modern interior design and apartment design does exactly the same thing these days. Everything looks the same kind of bland.

I’ve been through this thought process many times and I’m not comfortable leaving a device like an iPad permanently connected to AC with a battery that was never designed for that. I can just imagine ending up with a spicy pillow, except now it’s plugged into the wall all the time.

Oh I totally get that; I just don't understand why someone like DHH actually thinks that you don't have to read the code, if that's what he actually thinks. He's not a clueless C-suite.

Yeah, someone should just do an Elixir port that blows his out of the water if they really want to prove the point, with benchmark numbers.

Yep AI will just invent the missing stuff; that's not purely an AI thing, we do the same as well until we become experienced enough to know what questions to ask in order to narrow down vague requirements.

If I'm tired, yep I'm going to write more sloppy code, I'll put less thought into it and be more tempted to tell the AI 'just do it'. That hasn't changed. I'm not sure where this new breed of "don't read the code" is coming from when it's actual software engineers making the statement; maybe it's just over-excitement and it'll die down (hopefully).

Or it's just over-simplification -- I don't read ALL the code either anymore, but at the same time I'm reading SOME of the code. Tell your AI agent you're doing a code review workshop, ask it to select ten files at random and then go through them with you one at a time. Ask it to review common anti-patterns and put them in your coding standard. Then you can start asking it to review and fix code against your standard as a first pass. You'll still need to manually review the code to keep it in check, but at least you can make it a bit less daunting and a little more fun by actively collaborating on the AI with the review.

I'm learning it's just a 'different kind of tired'. AI has made some stuff much more efficient, including the choice between efficiency and carefulness. You can make that choice at a micro level and very quickly now if you want. There's still fatigue though, it's just a different kind of fatigue. You still get tired from all the thinking. You can still choose to put the work in or not and it still makes a difference. It's just a different kind of difficult. Doesn't mean that the thing to do is to throw your hands in the air and declare that your job shouldn't be difficult or include hard work anymore.

Daaaang you're gonna be pleasantly surprised if you haven't seen it already; look up what's happening with decompilations and recompilations now with AI :)

I almost feel like we need a different word that doesn’t have the confusing association. Like scratching your car (‘little t’ trauma) vs smashing the frame (big ‘T’ trauma).

Yeah but that's just bad code in general, no? You can make good code with LLMs, you just have to actually engineer it and give up some of the velocity; which is just a bigger version of the same problem we've always had (yes, I get that code review can't scale).

This is just really silly.

The more I think about this the more I think it's like self-driving cars. We have this expectation that self-driving cars MUST be 101% safe and never get into any accidents, ever, before the technology is worth adopting. LLMs are the same -- it's like we think if you can't one-shot a prompt and get perfect software out of it, it's failed. You can choose to spend time getting the LLM to refine the code it's written, review the architecture, come up with an actual engineering process around the LLM. Yes that means you'll be producing less code per time spent -- which is a good thing.

I specifically work in tooling now, so this probably applies more to that domain than some others, but I find 'very up-front spec-driven development' unappealing for that kind of work.

I'm experimenting just like everyone else, but this is my process right now:

- Quick prototype

- Figure out the language of your app (what terms you want to use for things, what your UI design language will be, etc) and spec that, so you can use words consistently with the agent. You need to be able to describe the things you want well and consistently.

- Keep prototyping. Let the agent write unit tests along the way. Lock down behaviour you like, keep track of those things in a document.

- At some point your idea of the real architecture comes into focus, from actual use cases -- avoids the over-abstracting right away trap.

- Refactoring is cheap with tests, so start refactoring into the architecture you want.

- Your architecture won't necessarily be what would be best for a human, but it will be pretty close.

- Keep relentlessly iterating on small work.

- Things that were expensive before aren't that expensive now -- integrating a library, changing from one library to another, trying out a few architectural refactors, trying out different performance optimizations, etc. That stuff is all 'throw it there and see what sticks' now, so don't be afraid to try stuff which felt big before.

I feel like 'front loading' too much is just the wrong approach. You might feel like you're sitting there 'babysitting the agent'; but that's just what the hard part of the work (hard as in 'zjust slogging through it', not as in 'conceptually complex') looks like now. Your code is much more like clay.

Atleast that's how I'm thinking about it so far, but I'm not working on large sprawling systems that I imagine would need more pre-planning.

AI has vastly changed the shape of what that looks like though. There are whole classes of refactoring work that are much cheaper and quicker to do with agents. Integrating a protocol client library say, or swapping one library for another are now potentially hour-long instead of days-long tasks, especially when you have test coverage to back you up (which AI also immensely helps you with).

I remember hating math from late primary school to all through high school. I never learned my times tables properly. They were just absolutely boring AF. What I didn't realize at the time though was that I basically set myself up for failure. When the basic building blocks are hard, everything else on top gets unnecessarily hard.

I remember reading Lockhart's Mathematician's Lament and loving it. I discovered that I actually liked math when I was able to let go of the "there is only one way to do things" and realize that math, in a sense, is 'made up but logically consistent' (notwithstanding the arguments about whether math is innate to the universe or invented by man, which I err more on the innate side -- I'm thinking of a slightly different concept here).

When I learn something, I always need to know the why. We were never taught that in school. "Just because" has never been a good enough answer for me in anything I want to learn. Learning about the history of the problems, why certain solutions came up as solutions and why they were needed in the first place made everything much more concrete for me.

I've been using ChatGPT over the last month or so to re-learn my times tables and basic arithmetic from the ground up. I had no idea what 'automaticity' was (I never developed it; I still would manually count simple multiplications in my head or on my fingers). I had never made the connection between algebra and arithmetic -- at least not deeply. In that you can manipulate arithmetic expressions just the same as algebraic ones if you want (72 - 37, you mean I can subtract 2 from both sides first to make the calculation easier?!?!).

Now I'm motivated though, because I know why I'm learning it. I can look at it with my adult brain. I guess it's a bit like the difference between a kid being forced to take piano lessons and an adult that's really motivated to learn and practice because they suddenly discover they want to play.

Oh and 3Blue1Brown is amazing!

Fixing stuff by driving an LLM to do it seems like a distinct skill unto itself. It’s kind of this blend of your normal debugging skills, carefully managing what goes into the LLM and carefully constructing your requests.

For me at least it’s the one thing that feels like a novel new skill to learn more than anything else. Normal LLM prompting feels like just an extension of the mental process I’d use when coding and designing in a way that trying to get the LLM to fix things kind of doesn’t.

Where is the line though?

If I write the song lyrics myself, does it become valid art then?

If I listen to it and then use that feedback to adjust the song structure, because it’s not giving me the feeling that I want to convey to others, is it art?

If I then repeat that multiple times, is it art?

What if I then record my own guitar parts or vocals, what then?

I don’t necessarily think these things can have an answer but I outright disagree that “if AI is used then the thing that’s made is categorically not art”.

I think it was Dr K of Healtgygamer that explained it something like non-toxic shame is a useful signal — “I did something wrong and this is a signal telling me so; I need to correct my behaviour” vs toxic shame as in “I am fundamentally a bad/worthless person”. We kinda got the two tangled together and in trying to reduce the second, we probably demonised the first a bit too much.

Could be remembering wrong though.

Yeah. It’s also far too tempting and far too easy to keep adding features if you don’t make yourself disciplined about it (which is okay if you’re in a position to control that, not so good if it’s the higher-ups demanding it).

I think this is something we’ll see AI very meaningfully impact — the threshold needed for “Get this thing working on a tech stack we might not be familiar with” has gone waaaaaaay down.

But that's a lot more words than "I found these issues". I also don't particularly care that 'Tool x ran for x amount of time', I don't want it re-telling me that -- I've probably been sitting there watching it do that, so I already know.

Then again, I just dont have an issue with the 'I-isms'; it's a bit weird sure, but at the same time it's a bit more pleasant to interact with as well. After all it is trying to model itself as a person you're talking to.

I have fond memories from back when Pixels were actually flagship. The Pixel 2 is my nostalgic pinnacle. I'd totally forgotten about that squeeze gesture until I got my old Pixel 2 out to erase.

I've found that LLMs are specifically bad at a certain kind of debugging, though I can't quite put my finger on what that is.

"Spot the bug in this code" when the code can be looked at and pattern-matched against bugginess is something they seem really good at.

Some parts of debugging, like "Here is this logfile, what do you think is going on?" are also surprisingly good.

It's that thing kind of in the middle -- I know it when I see it honestly is the best way I can put it into words. An example from recently, I'm receiving some bad data on a network message parser. Immediately I don't know whether it's a my-side or their-side thing, but I know if I try and just vaguely describe the behaviour to the LLM it will start churning tokens.

My current approach to problems like this is -- I need to tell the LLM what it needs to do to give itself the data it needs to solve the problem. My first reaction now isn't "It's not working, there's a bug, it's not doing X". It's "Okay, this isn't quite working properly; I need you to add some debug logging around X, Y and Z so we can figure this out". That tends to avoid spirals and get me out of the situation much more quickly.

The seeing eye dog analogy is pretty apt actually. I would love to see some transcripts from the author if they are able.

Edit to add: I think the 'thing' I'm alluding to might be -- if I have trouble expressing the buggy behaviour clearly in words, then I know it's probably going to be a fair few back-and-forths with the LLM to get something; the harder I find it to concisely describe, the more risk that it'll fall into a pit. Doubly so if I offer up a hypothesis which turns out to be wrong.

I'd love to know if there's a documentary or something that has been done about this, that I could point non-techie people in my life to.

It’s a tiring YouTube formula:

“Model X CHANGES EVERYTHING!” (surprised Oculus Rift face without the headset)

Some one-shot prompts for quick impact.

I get it with the incentive structure — honestly not trying to shit on any creators (hate the game, not the player) but seeing it every day is just getting tiring.

I have some memories that I know for a fact are wrong in a pretty particular way. They’ve either become attached to the wrong place or the wrong time.

Like I remember a good friend picking me up from my childhood home, yet I didn’t even know that person until I’d long moved out (many years) from that place.

Oh damn that BASIC :) I remember as a kid going to the library and devouring all the microcomputer books and trying to enter their BASIC programs, only to find the C64 severely lacking. Everyone else's BASIC was better!

I wanted to get into assembler as a kid, I'd read about assembly in computer magazines and wanted an assembler cartridge one year for Christmas, but that was a hard thing to find back in the day, so I kinda never did.

I did get the Simon's BASIC cartridge though -- that added a heap of stuff! I remember writing some massive (for me at least, being a kid) programs at the time -- games that I would spend weeks on but never finish; I fondly remember the 'big' projects I had as a kid.

It's funny this is at the top of HN right now. Since going nearly full agentic at work, I'm actually finding I've got the urge brewing in the back of my mind to go right back to the beginning and do hobby programming on a small system again, now that I'm not using up all my 'writing code' energy in my day job anymore. I'd love to go back and re-take my path and pick up on all the little things I never understood as a kid.

I've got the C64 Ultimate.... don't know if I see myself typing on that keyboard layout though.

I get the nature thing, but people just don’t ‘play the tape until the end’. It’s all nice until you get a minor cut and die from a simple infection.

I’ll dig up the references but I believe they were studying what happened to LLM performance as the complexity and verbosity of the code went up (ie- just letting the LLM rip without doing explicit code cleanup and simplifying).

I feel like we also miss something related to #2 (Discipline). I never needed discipline to sit at a computer coding as a kid for hours on end — if anything I’d have needed massive discipline to NOT do it.

I wonder if what we call discipline (and the resulting skill that we call talent) is really just insanely strong and aligned interest.