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

Absolutely. I was a high school teacher in the 2010s, and it was such a hard aspect of teaching to navigate.

For any reasonable phone policy to be implemented well, it has to come from the highest level of administration. It has to be enforced consistently across all levels from the district/principals down to individual classroom teachers. That requires a lot of people to understand the issue well, come to agreement, and be capable of enforcing difficult policies.

There are so many factors that make it difficult for this to happen. Parents who disagree with policies, often for valid reasons. Staff turnover makes consistency difficult. If one teacher lets students use phones, it makes it harder for everyone around them to manage the policy effectively. If groups of teachers don't adhere, it gets even harder.

This is no different than the impact of AirBnB on housing availability, especially in tourist destination towns. Tech companies create a situation that's really hard to manage, and then leave it to individuals and small organizations to manage something that really needs to be figured out at a societal level.


I had lunch with a couple friends this week, and we each work in different tech environments. Most of the conversation was about the workflows we're each using, and seeing our colleagues use.

It's a really interesting time to work in this field. People who are paying attention to workflows are using a range of tools, and constantly refining their own workflow. For example a whole team might use Claude, but one person collects data about their own usage on an ongoing basis and develops more advanced workflows than everyone else on the team. Their focus isn't just about working faster, but about doing better work.

I don't think the post is vague; I think we're at a time where you need flexibility in your interview process to find candidates who are doing the best work these days.


Thanks, that certainly clears up the doubts

I've only implemented support for one provider at the moment, but it is structured in a way where I can add support for any other providers or local models. It feels good to not be locked into any one company's models or harness.


Yes, it's so easy to build a harness for a lot of use cases now, and you learn so much from doing so.

I'm a solo developer, and I didn't want to sort out all the boundaries and permissions of Claude or other heavy harnesses. All I wanted was something that can read, write, and modify files in a project directory. I gave myself three days to see if I could make a harness that was complete enough to work on my own projects. It was usable in less than a day.

I love using it, because I know exactly what its boundaries are, and how they're enforced. When I need more features I can either implement them in my own harness, or choose a heavier harness with much clearer understanding of what to look for.


Any tips on how to get started?


Claude, build me a harness.


When people have gotten excited about having so many tests, I've asked them what their plan is when 500 of their 1000 test suddenly stop passing. I've always favored 50 tests I know are meaningful, where any failure is something to respond to, over 500 tests with a bunch of overlap and edge cases I'm not sure matter. But now people aren't even thinking about that, they're just letting the agents make all those decisions.

I think this approach will continue to work for some people and orgs, but others are going to hit walls where their agents can't manage the mountains anymore. It's going to be interesting to see how people and orgs respond when that happens.


    > I've asked them what their plan is when 500 of their 1000 test suddenly stop passing
That's not a terrible thing; would indicate that some shared behavior is broken and -- assuming well structured code -- hopefully easy to isolate the behavior.

Bigger problems to me are more practical: 1) large tests waste context both in and out, 2) large volume of tests waste CI cycles which are becoming the bottleneck.


IMO the solution to too many tests is to encode more things in the type system. If you can encode constraints like the length of an array in the type system you know it is correct if it compiles, and that is one less run-time test to run.


Agree, but this is not a pattern that is emergent from any coding agent I've used; it is only the result of explicit guidance to structure code in specific ways + relying on platform level analyzers.

But more specifically, I usually see the explosion of test code in integration tests where there is heavy setup of entity graphs.


Back up to the point where all the tests were passing, of course? Then debug.


or git bisect until you get the exact commit that introduced it


Yup, that's the way!


He doesn't really think, he reacts. And his every reaction is centered around "How can I make this about me?"


True, but his "handlers" are very smart and behind his rants there's usually a very deliberate motivation and accompanying action.


Yeah, that's what I'm trying to puzzle out... Surely there's some kind of objective here to justify this overtly aggressive language?

I mean he invaded Venezuela, and everybody knows he wanted the oil, it makes sense. This super intelligence stuff is not making any sense.


Maybe it's just a loyalty filter to easily see who is actively "bending the knee". If you use "AI" in your discourse it's a subtle sign you don't align with Trump. I'm not sure but we'll know soon!


Peter Thiel recently said that Trump's handlers are not smart but very loyal. Loyal to him, if that wasn't clear.


I don't consider Peter Thiel to be very smart. I've read his "sermons" for lack of a better word and they're just pseudointellectual nonsense, and tech-babble with a dash of religious justification to appeal to conservatives (Federalist Society/Heritage Foundation etc.) I wouldn't seriously consider anything he says to be viable. They're (Trump's cabinet/oligarchs) only loyal as long as MAGA loyalists keep blindly supporting Trump, the second the tide turns they'll scatter like cockroaches.


They don't have to be smart to be dangerous.


I like this article. We've read a lot of takes quite similar to this, and I think it's worth continuing to write and share reflections just like this.

> Yet, through much effort and 40 years of debate we had reached an equilibrium. Now AI has thrown that out the window.

The only thing I'd like to add here is that "AI" in this sentence should really be read as "the companies building frontier AI models have thrown this out the window". I don't necessarily think the author should have used a phrase like that, because it gets quite pedantic to read posts where such precise language is used all the time. But when we talk about where to go as an industry and as a society, we need to keep that distinction in mind.

The tech is here to stay, but the tech itself is not what's thrown our norms out the window. It's the people running these companies who are putting their vision and their profits above everyone else in the world. Most of us are exploring this tech and trying to figure out what it's useful for. It's a much harder question to try and figure out what to do about the people using this tech to consolidate wealth and power. We can't hold a technology responsible for anything, but we can hold people responsible for their impact on everyone else.


I'm the author of Python Crash Course, and I got this exact same email this week. I was thinking of writing a public response as well, because any attempt to sincerely answer these questions takes something along the lines of a full post. It's also worth a public response because many people who are getting into programming for the first time right now are asking variations of these same questions.

> Do I think that AI enables people to develop faster than they can keep up?

Absolutely. That's the core of this person's email, and everyone else who asks similar questions. Just five years ago, the only way to build a working project of moderate complexity was to learn the basic to intermediate concepts required to make an MVP. Now, if you can steer an LLM reasonably well, you can quickly build an MVP that goes well beyond your own understanding of the implementation.

I don't think anyone has clear answers to all the questions brought up in this email. I think people can learn faster than they used to, because they can make connections between different areas faster than they used to. But it requires skill and discipline in how you learn, and how you work. You have to intentionally build your understanding as you build your projects.


> Just five years ago, the only way to build a working project of moderate complexity was to learn the basic to intermediate concepts required to make an MVP.

> Now, if you can steer an LLM reasonably well, you can quickly build an MVP that goes well beyond your own understanding of the implementation.

Somewhat agree. Five years ago you could build an MVP without understanding how to open TCP sockets or how to parse HTTP headers. You didn't need to understand relational databases, let alone B-trees or cache locality. You didn't need to know how to install Linux.

Now you don't need to understand the details of connecting to Stripe or Auth0 or setting up a Kubernetes cluster.

> You have to intentionally build your understanding as you build your projects.

Some things you need to understand-others, not so much. Depends on what you're doing, the scale, risks, etc, but that's always been the case.


> Some things you need to understand-others, not so much.

This is the core of the matter though, knowing what you need to understand and what you can ignore is the actual programmer's skill. It requires you to have a clear mental picture of both what you are trying to build and what the underlying machine will do when you are finished.

You need to understand the abstractions, but also where they leak, when they won't match reality, and how. This is why knowing computer architecture and assembly helps you to optimize your code even if you are coding in a high level language.

The problem with coding agents is that they are tuned to work on all contexts so they always fill an underspecified request by optimizing the average case and often without stating all the assumptions that they make. So you still need to understand what you specified and what got filled in automagically by the agent. My experience is that they (even the paid frontier models) are poor judges of the most important assumptions they make, which will might be corrected by a prompt or a tool output in which case it is fine. Otherwise it will be ignored and steer the model into a weird loop. It then tries to fix things but can not do so since its mental model is totally broken now.

Do not get me wrong, I am so happy to let the agent handle tool building (especially those that involve a web UI) and fill in the CLI command line argument parser. But every time I trust the agent by relying on it to drive the mental model of what we are doing, I got seriously bitten. Well, maybe that should not be surprise me, but I can understand the confusion of less experienced programmers and non-coders. It must really be frustrating to be able to build so much, but also not to be able to fix seemingly small issues.


That's just it. you didn't "build so much", you didn't build anything. You asked someone (or something) to build it for you.

How can people look at LLM-generated code and think "this is mine, I made this" is beyond me.


Agree wholeheartedly.

I'd like to add: we can't know a priori what will be needed to be known and what can safely remain behind an abstraction you just use.

That is revealed when our mental models grind against reality. Avoiding that friction at all costs is a problem because it will happen and you'll be unprepared when it becomes unavoidable.

Trusting some abstractions that have earned it but not all is how we deal with it. Limit your focus, and adapt. If you just trust all abstractions thrown in front of you until something breaks irreparably, you will be (person or organization) between a rock and a hard place and without any knowledge or skill on how to get out of that predicament.

That to me is the biggest risk in accepting the fallacy of general automation.


I’m in two minds about this, in some sense they did and it’s the same way in which the C code I write is mine, but the assembly underneath is an artifact of my intent, but I owe the compiler authors for it. On the other hand the cognitive distance between my C and the assembly is likely lower, but that’s because I’ve spent time staring at what was generated in order to figure out why my code was misbehaving. Which is itself not that dissimilar to figuring out how to get better at writing code with llms.


If you ask LLM to code something for you, and you then work on the code, then yes, there is partial ownership. Just like if you had asked another, maybe junior, developer to write a piece of code, and then you helped them make it better.


I think the difference involves how many layers of stuff someone claims is "theirs" and whether that claim of credit and expertise is valid.

Imagine a coworker writes some decent C code, but then at a meeting they start taking credit for the bytecode and the default optimizations done by the compiler.

That's analogous to people who write LLM prompts and then claim the same level of authorship over the code which was all generated and edited on an indirect level.


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.


I agree that it is a bit weird, kind of coding in natural language but also not exactly like that. Maybe as the agents stabilize and there are proper new tools for this new process we can relax a bit and it will become the new normal. For now it feels like surfing over an ever changing seascape, exciting but tiring at the same time.


That’s the power of abstraction when there’s a good API around something to hide the internal that doesn’t matter much at an higher level. You only need ‘open’ and ‘read’ instead of dealing with disk access and file system trasversal.

But those abstraction are deterministic in nature, so there’s a very good guarantee of their behavior. Someone using LLM and not caring about the generated code is just asking for trouble. The code may work, but there’s no guarantee about its behavior (including error handling and edge cases).


non deterministic abstraction are absolutely useful, outside of software sector they have been used since the start of civilization ("a worker" is a very very non deterministic abstraction, outside from the most basic tasks)


I’m sure that in every case where there such non deterministic abstraction, it’s been always statistically or with a lot of hand waving. So with a heavy dose of expected errors.

Pro LLM users don’t want to talk about the error margins of whatever practice or product they’re putting out.


> "a worker" is a very very non deterministic abstraction, outside from the most basic tasks

Sure but we (usually) don't fool ourselves into believing otherwise. The problem with AI is that it suggests near-perfect intelligence with reproducible results. So many people are not acknowledging the fundamental limitations of LLMs, whereas we all have an intuition for the limitations of humans.


In addition to the reliability/security aspect, there's the claim to expertise and unwarranted confidence. We also don't (usually) fool ourselves into believing that the manager has gained the skills and expertise of the worker, simply because they gave abstract orders and a good result was achieved.

In other words, "I can code because I prompt an LLM" is like "I can do metalworking because I sign the paychecks of a blacksmith."


Well said!


> The code may work, but there’s no guarantee about its behavior (including error handling and edge cases).

But the painful reality is that we never had any such guarantees in industry code to begin with; despite decades of writing on software engineering best practices, software from the biggest companies is often bug ridden.

My experience might not be representative, but when I do my "old man yells at clouds" routine (which I do multiple times a day), it's a lot more often targeted at Microsoft and Google software than at "vibe coded slop".


This is exactly true in my experience. I find myself trusting the LLM better than I ever trusted a development team to deliver accurate work. Just like you would managing a team of junior developers, you have to keep an eye on the output, but I think the agent is more transparent about that than your team would be. And it works faster, and you don't have to deal with emotional meltdown or active sabotage if you criticize in the wrong way.

The trick for the guy controlling the agent is to know about the gotchas that one would normally encounter when doing the work. Asking the right questions and mentioning the right things to pay extra attention to can make all the difference.

I think that's why it will be much more difficult for people to learn how to make software now. Those of us who have been doing it for years and years have experience that is valuable in steering the LLM. It will be hard for people new to software to get that same experience. But then things are changing so quickly right now, everything I just wrote my be irrelevant in a week.


> find myself trusting the LLM better than I ever trusted a development team to deliver accurate work

That’s the main issue. You’re talking about the development side guarante, while the most important is the user side guarantee. There’s a lot of talk about liking LLM interaction, but no comments about the software quality, which for a lot of SaaS has gone downhill. It’s why they emphasized LoC and number of PRs but hide the number of bug tickets.

Which is why the most enthusiastic comments are about projects not released yet. Greenfield and released projects are different.


> but no comments about the software quality, which for a lot of SaaS has gone downhill. It’s why they emphasized LoC and number of PRs but hide the number of bug tickets.

And here's some numbers (gathered from telemetry over time) showing that: https://www.faros.ai/blog/ai-acceleration-whiplash-takeaways

Here's someone's breakdown (with some things from the full report that aren't in the Faros blog post), showing how it's even worse than first impressions: https://unessays.substack.com/p/talk-is-cheap


> it's a lot more often targeted at Microsoft and Google software than at "vibe coded slop".

What makes you confident the Microsoft and Google software isn't vibecoded slop?

Certainly Microsoft has made a lot of noise about all their software being LLMgen these years, and also gotten into hot water with their users for Windows 11's crappiness.


Very good point. I would respond that I saw the deterioration several years before vibe coding became a thing, but maybe they did have a head start on the tech.


That was them killing the QA team that really kicked off the apparent to end users lack of quality.


>My experience might not be representative, but when I do my "old man yells at clouds" routine (which I do multiple times a day), it's a lot more often targeted at Microsoft and Google software than at "vibe coded slop".

As in you get more mad at software you actually use being broken than software that you aren't using and just exists in blogposts?


I personally work a lot with vibe coded software, both my own and of others. And I do encounter a lot of issues, but in general they annoy me less than the enterprise engineered ones.


There's a pretty significant difference there, even in some of the examples you picked to make your point. TCP and HTTP are well defined standards that, for all their flaws, were designed and conceived to be useful abstractions that you didn't need to understand deeply in order to use. The things that LLMs allow novices to skip nowadays aren't designed with that in mind, and generally aren't something you can just skip over without getting yourself into hot water later. If you mess up Stripe or Auth0 setup because you don't understand the implications of the boilerplate the LLM spit out, you can very easily get your whole app compromised or end up on the hook for a lot of fraudulent credit card charges, etc. I see the point you're making and I don't entirely disagree, but I think current iterations of LLM coding tools still make it far too easy for beginners (or even fairly experienced engineers) to convince themselves that a detail falls into the former category of abstractions they can safely skip understanding, when they're very much the latter.


imo that’s a good thing and people will gravitate towards companies that build actually good platforms.

with a bunch of competition, the best will be incentivized to not have these noob tier issues.


>Now you don't need to understand the details of connecting to Stripe or Auth0 or setting up a Kubernetes cluster.

Ehhh, if you're smart you want to at the very least gloss over the details, and look at the code being generated by whatever model you're using for this solution.


I think there might be a take on learning with AI vs the pressure to develop fast. AI could be an amazing tool to learn. But who wants to learn when you had to deliver 3 days ago? The corp culture is kind of what is killing it. Not sure how things are going in universities tho. If you stop and use it to learn, take time, ask questions. I am sure you can learn a shit ton out of it, most people were learning in the beginning when you had to copy/paste/debug in chatgpt. If I had to answer to this, I'd say that learning has become optional, helpful, but optional. Not in the sense that it is not good to learn it (or anything), but in the sense that you need to opt to learn it, and to do so you will have to sacrifice speed. Do what I say makes sense?


I'd quip this summary, only half tongue-in-cheek: "the goal was never to learn things".


well, does it all boil down to capitalism?


> I think people can learn faster than they used to

Agree, but that only applies for people who were experienced developers before AI took over. Let's see in 5-10 years what our caliber looks like when you skip the foundations.


If you’re just talking about learning a programming language I think you need to be quite judicious in your AI usage.

In my experience, people learn programming languages best by overcoming frustrating roadblocks. You often end up learning something important, even if it’s just about your mindset or approach, that landed you there. This is the difference between someone with a wet signature on their comp sci diploma and someone with a few years under their belt.

A lot of people start with tutorials and cargo-cult their way through solving their first problems, but eventually need to learn how to do things the tutorial code can’t. It seems like the AI coding tools can could perpetually make things that could be bashed together well enough to sorta solve a problem and think “oh I’ll just learn about that later,” and then never learn about it at all. If your goal is to make some quick tool to help you with something at work in a different field, well, touchdown. If you’re trying to learn the language, fail.


>> If you’re trying to learn the language, fail.

AI-coding tools are the deepl/gtranslate of coding. they might help you understand a foreign website/text better but you wont learn the language with it. and you will continue to be reliant on them until you learn the language. So when you dont have internet access etc.

For programming, this was already true for many programmers before LLM. I wasnt able to do much without access to stackoverflow. especially with more complex tasks that i had no experience working with before. Its one thing to figure out an elegant solution to a concrete task, but often it was remembering integrations, libraries, adapters and packages i dindt often work with.

So i agree fully, learning a language takes time. The central question is, why are you learning the language? for personal development? for understanding the process the LLM is solving for you? for deep optimization?

i can do a fluent translation from german to english for my GF, but sometimes its too exhausting and i paste a text into a translator (or llm) and just read the english text. The same is true for coding. When nuance is important you might want to have a skilled programmer look over what you generated.

BTW does anyone use the LLM to directly generate assember code :D


Yes, there is a funny PR in open source project about refactoring source code to assembler code or even machine code 0s and 1s. I do not remember exactly but I remember I LOLed hard when I saw it.


Completely agree with the failing part. It's in these moments of "failure" and "struggle" that learning actually happens. Productive failure is a well researched concept in education - https://pubmed.ncbi.nlm.nih.gov/31089856/


I’ve seen people here learn programming languages by building a compiler, but my go-to project is usually the ICFP 2006 contest. It has a well defined scope, it is entertaining, gets you into the advanced concepts pretty fast as you debug and optimize performance.


> Now, if you can steer an LLM reasonably well, you can quickly build an MVP that goes well beyond your own understanding of the implementation.

Pre-LLM, I'd distinguish between e.g. "I know Python" and "I know this codebase". So if I wrote a codebase in Python I'd be familiar with it, if someone else wrote a codebase in Python I'd be familiar with the Python. -- An LLM coding agent can give a codebase in Python very quickly.

With a newbie, they'd be familiar with neither; but an LLM coding agent can give them a full solution written in Python.

I'd say that this power from LLM coding agents blurs the distinction, in some sense. But to an extent it's always been the case that abstractions allow programming without a full understanding of everything down to atoms.

People 'can' learn faster than they used to. But I'd think those who are curious to learn will be able to have better results than those who only have a shallow understanding.


I suspect my opinion on this won't be very popular, but it's like driving a car. If you're going to learn how to drive four wheels, you should start by taking the motorcycle safety course and learn on two wheels first. We can discuss why later.

Taking that concept to programming, I wouldn't start with a desktop or a web app. I would start with a little embedded system like an ESP32 or one of the small Raspberry Pi controllers (2350). I've come to this opinion because of the people I've mentored as they improved their code-writing skills. The ones who did best were the ones who started with embedded systems.

I believe you have to get down and dirty with the machine to understand the code and what it's doing. If you're making a motor controller work, you can use an LLM to generate code using a library or some cut-and-paste MicroPython code. But when it doesn't work, you have to break out the cheapy mini scope you got from Amazon and look at the waveforms.

Seriously, get your hands dirty at the controller level; understand queues as driven by hardware, not hidden in a library. Or, even simpler: you need to understand why the blinking lights are blinking, but not the way you thought they would.

If I were writing a course on programming, I would give students deliberately and increasingly wrong cut-and-paste code and leave the solution as an exercise to the reader.


Are you seeing companies that are in over their heads because they don't have enough domain knowledge?

I think that's always been an issue in tech, but it feels like AI exacerbates the issue. I see people starting companies and services where their primary domain knowledge seems to be whatever their AI tells them. It's sometimes enough to get off the ground, but I wonder how long it takes for customers/clients who actually need the domain knowledge to bail.


I'm seeing it at small scale around me. I view it as a Dunning Kruger enablement - AI gives confident answers and long-winded explanations on domains distinct from the person asking, making it hard to verify. The user of AI now feel they have replaced someone's advice. I see it in Technology at work (particularly in architecture) but also in non work things like plumbing, law, medicine. We're all doctors and physical therapists now, for example. Also we don't need psychologists, either.

Everyone is obsolete. Just upload the MRI report to Claude and let it tell you what you should do.

When people talked about AI being a catastrophe to befall us, I thought people were picturing killer robots. What's happening instead is something else - the enablement of stupidity.


For a bit of context, Juneau Alaska deals with a smaller scale version of this most years. There's a bowl off of the Mendenhall Glacier named Suicide Basin. Each summer that basin gets filled with meltwater, which forms a lake because the glacier blocks the water from leaving the basin. At some point the lake fills with enough water that part of the blockage gives way and the lake suddenly releases.

In Juneau, this is a well-defined basin with well-established dynamics. The city still wrestles with how best to handle this. Recent years have seen higher river levels when the basin releases, and the downstream banks of the Mendenhall River have eroded much faster than people were expecting. The city and individual homeowners are engaged in multiple projects to manage the annual flooding.

In the Nepal case the scale is much larger, and the variables are less known and less stable. This is absolutely devastating to see.

https://www.adn.com/alaska-news/2026/08/12/juneau-officials-...


Reminds me of the Fargo-Moorhead diversion project. The Red River flows north through Fargo, which means that down-river portions can ice over in the winter and cause upstream flooding. The diversion project should wrap up soon, and hopefully it works. As I understand it, the city is going to appeal with insurance companies to drop costly flood insurance requirements.


I completely disagree. The variables in these situations are WELL known. The difference is scale, and in the Himalayas there is no cost effective, completely safe way to deal with them. The hydroelectric potential in that part of the world is the main driver for the continuous build -> flood --> destruction --> build cycle. Obviously, the last event was nothing short of astonishing, devastating and horrific. The worst part is that it will happen again, just differently.


> > the variables are less known and less stable.

> it will happen again, just differently.

It seems to me that the two of you are actually in agreement. If we had a better understanding of the variables we'd have been able to predict what happened in advance from the reams of satellite data we have.


No. It will happen again the only thing that will change is the amount of water and debris. More or less people will die depending on the incentives to live in the district. Humans should not inhabit those valleys.


That's not a response to what I wrote? If we had a better understanding of the variables then we'd almost certainly be able to leverage all the data we have to warn people in time to evacuate. Similar to how wildfires used to kill a lot more people but these days even in the most fire prone regions you'll almost always have time to get out if you heed the evacuation notice.

I agree with you that flood prone areas are generally a poor choice of place to live but it seems to me that's neither here nor there.


What do you mean the hydroelectric potential is the driver? Is there a word mistaken?

There is no electricity production?


I think they mean a resource ripe for extraction. There is huge stored gravitational energy in that ice and water up so high, which is also exactly why it was such a disaster.

Potential as in possibility, not as voltage. It's an awkward phrase...


> It's an awkward phrase...

You might even say it's charged.


Potential and actual as in voltage.


Huh? I mean, if you look at the actual damage reports you see quite a bit of energy taken of both Nepal and Chinese grids. Further deduction leads to the obvious conclusion that hydroelectric generation in the district is VERY important.


Yes, most of our problems with the shifting climate are not physical, their not engineering, they're nothing but stupid, stupid "social studies". The kind of thing billionaires want to buy their way out of, which they can't, so they do the next best thing: abandon all hope and build their bunkers cause real philanthropy is complex, and real society isn't just something an LLM can dictate and people will just follow.


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

Search: