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

> The cost of AI is rapidly falling while its engineering capabilities keep rising.

Wouldn't count on it. There likely is a ceiling, we might or might not be near it.


Definitely with the cost. I strongly believe the price now is heavily subsidized and will shoot up in the future. (Not new. First hit is free..)

Often enough for those android devices you already have the sources for most components but only compatible with some age old android kernel and it's "just" porting it and poking around. LLMs are quite good at this.

I think a lot changed for them. Doing all this while often beneficial was very tedious and time consuming by itself, way easier now. Of course they profit even more because they've already got the habit.

Kind of a common issue for python CLI tools. If you use its module import system idiomatically it leads to a lot of unrelated code being executed and being loaded into memory, something lazy imports [1] aim to solve (at least partially).

[1] https://peps.python.org/pep-0810/#motivation


Yep, fully leaning onto those subsidized subscriptions and closed models is dangerous. At the very least keep it at a level where you can fallback to some cheaper, preferably open model which has predictable pricing you can actually afford.

> "but a blacksmith is who i am, i don't want to just pull a lever and push a button and out comes a part. How can you truly know it was made with care unless i do it myself by hand?".

I think this is the place where a lot of "coders" are now, they only cared about the manual part of the job which is gone.

What's different in software is that developing software always kinda was building and designing factories spitting out copies at the end (while actually creating and distributing the copy increasingly being the easy part). So in this profession you have a split between people who were actually only in for the manual part of building the factory while you have others for whom the manual part always was just a means to an end. With the purely manual part gone there is still a shitton of work left which is in the end a lot more complex and challenging than mere button pushing but it's different work.


> they only cared about the manual part of the job

I think this is a very small part of the population, if anybody. Craftspeople, perhaps definitionally, are people who care about the work of making AND the results. This is true for many many devs.


> I think this is the place where a lot of "coders" are now, they only cared about the manual part of the job which is gone.

That argument has been repeated so much while all the experienced developers keep saying that coding was not the hardest part of the job. The hardest part was adding the new changes while ensuring the system doesn't break and that it's still easy to modify later. In the latter case, intuition plays a big role into labeling what is a core truth of the system (unlikely to change) and what is a transitory need.

Coding was just something you do (and relax while doing so), not something you put your whole being into. When I code, I mostly think about the system. Which is why I look at the docs and my notes often to check the semantics of whatever symbols I want to use. I don't think about the actual typing of the code.

That's the actual argument against agentic coding. No one is checking semantics, it's hope and prayers that the software is correct.


> The hardest part was adding the new changes while ensuring the system doesn't break

The hardest part, by far, was ensuring you were delivering value. It was, and is, all too easy to build something technically impressive but completely useless.

Verification isn't nearly as hard. We understand very well how to minimize the chance of error. With humans involved there is still room for mistakes, of course. There is no such thing as a panacea. But the space for failure here is significantly smaller than in the above.

> it's hope and prayers that the software is correct.

I don't think anyone has thrown away their verification systems. If anything, they've doubled down. And for what mistakes can be made within verification, LLMs are quite good at recognizing those mistakes, so it is likely that software has never been closer to being correct. There is still no such thing as a panacea, but we're a long way from relying on hopes and prayers.


> The hardest part, by far, was ensuring you were delivering value.

In most software, value is not solely about new features (to get new customers), it's also ensuring that existing features work smoothly (so that customers don't leave). I got maybe one or two features to deliver each quarter, but I could spend all days hunting down customer bugs.

> Verification isn't nearly as hard.

Only when you're experienced enough to design the codebase to ensure so. It's easy to write un-testable code. And so many times, I've seen code being written with no clear requirements. And the dev does not track what is a hard constraint versus what assumptions he has made. It's up to the user to test the software and fixing each bug is like hunting in the jungle. It's that attitude that get amplified by LLM tooling.


> In most software, value is not solely about new features

I admittedly missed the discussion about new features. Maybe you can help me circle back so that I can understand what you're talking about?

> It's easy to write un-testable code.

Is it? Many verification systems won't allow the code to compile if code isn't verified. I mean, you can write code that won't compile, sure, but I don't think that's what you're trying to get at, so whatever it is you are trying to get across may have gotten lost?

Maybe you're trying to say that that verification exists as a gradient and you can write code that is verified in one way but it is easy to miss other ways it could also be verified, and that, in general, full verification is mathematically impossible? That is also true, but that's why it isn't a panacea. It is still a lot easier, even if still hard, to live in that realm than it is to deal with the value proposition of software.


That's a big problem I think. We should use those tools to improve applying our practices. Along the way we might figure out that we can and should do things differently. But just throwing everything away, hoping for the best, does sound like a recipe for disaster.

You can push the agent to write succinct code by working in small steps, going back and forth. You push the agent in the right direction but also the other way round because it finds a lot of stuff you might have missed, esp. in complex areas. It also oftentimes does quite reasonable things actually.

You definitely can use those things to improve both speed and code quality at once. But then your speedup is while quite noticeable not astronomical of course. Also the work isn't easier (apart from less typing), just different.


For some uses cases I think this might even work out well enough if you figure out and apply the right guardrails and boundaries. That's quite a big if though...

There is a difference though. Railway lines and fiber last decades, GPUs will be out of date in a few years and the chips will probably just die at some point anyways. Also datacenters are barely getting finished and GPU clusters sit in storage. They are kind of useless without those datacenters though as they need specialized infrastructure.


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

Search: