Recently I asked an agent for a feature where the screen will get dimmer after some time, and eventually after a day the screen will turn off and then turn back on if I tap, which should be pretty easy in esphome.
But: some past agent decided what it wanted wasn’t in esphome, so it made its own custom module in c++ for the display, spelunking in pdf datasheets; then the weeds were so deep the new agent decided to add on to that, and to read the power controller and display controller spec sheets and somehow implement my dimming feature by writing raw values to some nondescript registers.
The contraption worked until it didn’t and once every so often my esp32 would just completely hang with black screen and no connnectivity and needed a power cycle, presumably because whatever low level register writing the agent implemented eventually breaks something. I told the agent to get rid of all custom stuff and wherever possible just use default esphome yaml, now it’s been working fine. I don’t really have a point with the anecdote, just that I’m also getting tired of such scenarios like the OP.
Then you'll get shit like custom JSON parsers or config parsers made from scratch instead of importing an industry standard library.
This... quite describes what the current AI feels like to me. So I really don't see a problem. If AI does too much for you, you should, uh, just prompt it to do less.
Everyone talks about how their AI escapes sandbox and virtualization or delete their entire repos or something. Perhaps they're using a skynet I'm not aware of. From my experience when I added "discuss; don't edit any file yet" at the end of the prompt I've never seen the LLM go against my will and edit the files anyway.
depends how long conversation gets and he will still ignore your instructions randomically. I think shorter sessions are better, I do have a similar prompt saved on the memory of the agent and way more times that I can tolerate, he candidally ignores it
I use the almost the same addendum as you ("do not make, commit, or push any changes without my approval") and it broadly seems to work in my day-to-day dev. However, I also set up some agents that trigger on incoming requests from my dev teams to automate things that used to be rote/manual tasks. _That_ is where I see the issues, I suspect simply because it has so many more opportunities to go off script.
The most common failure mode is that it will, despite all directives to not make changes without approval, start writing unit tests. (I do find this equal parts head-shaking and amusing; At least it chooses something relatively 'benevolent' vs. the aforementioned skynet.)
If you're running Claude via -p automated mode, you can set all kinds of permissions and access to each individual editing tool, much like you would with firewall software.
It doesn't edit the system prompt, it blocks access to the tools itself. Just make sure you haven't given the AI the ability to edit its own configuration files, or you'll potentially have an OpenAI v Hugging Face situation.
Much of the transformative power of LLMs has come from dumb logic wrapped around them that either changes what is fed to them ("memories", "thinking/reasoning", etc.) or how their output is interpreted/acted upon (agent harnesses, loops, etc.). For this reason, Anthropic could release "Claude Necronomicon" tomorrow and tell us it could hack the planet and gain control of the world's nukes, dooming us all, but until it's actually hooked up to something that enables the execution of those commands, it can't do squat. Of course, that's no reason not to worry since some idiot is likely to build that torment nexus (and they may well work for Anthropic), but at the end of the day the thing is still just predicting tokens and everything else it seems to be doing is being faked with clever massaging of the input or output.
I think the solution is toward more formalization of the behavior we expect of various systems. E.g., produce a Lean proof that a program never behaves in a certain way, and if you can’t, iterate on the program until it satisfies such a proof. I’ve only tinkered around with this a little bit, but it seems promising on toy problems. Scaling up to tech-company level infra is going to take quite some time however I think.
When carpenters moved from mostly hand tools to mostly power tools, it didn't take away much of the need to understand the techniques of woodworking, it just made it all faster.
Reading a nonfiction book is very different than reading a book summary, even if (as is often the case), the ideas in the book could have been condensed way down. The point is that actually reading the whole book means you spend far more time engaging with the ideas, and so they become more deeply embedded in your neural network. In things like sports, this is just obvious, in that no one expects someone to become a good soccer player by just reading the rulebook, and obviously more practice is the main way you get better.
Creating products with AI is like creating a tightly packed ball of wool. Then, to try to understand what happened you have to somehow pick a strand and pull it out to have a look. Very difficult with tightly packed wool.
I've run some experiments in the past month that get me closer to being able to work with this opaque bundle.
It's the main thing I think about every day, how to solve this problem.
My LLM is an assistant that helps my designs and decision process, implements the final work expertly, and I'm always in the driver's seat. And the development speed is astronomical.
Now, I'm back to rubber-ducking until I've built my own mental model over a few days of thinking.
You aren't going to get that. Why would they even offer you that? You're going to be the meatbag peripheral to an AI.
And that is literally how a large number of programmers, including Anthropic themselves, are using CC - they are simply a meatbag peripheral to CC.
> I don't understand the hysteria.
Maybe ask an LLM to explain it to you using analogies? They can explain anything, even if they are wrong.
Right now we’re still in the benchmaxxing phase, I feel like most AI models of combination of models and harness are not really a “product” yet in the sense of having a particular and opinionated UX engineered to be helpful at a specific task, there much more still in a race to be the smartest.
There’s a lot of room for diversification of the actual character of this interaction, for example in the direction you mention. I think once that starts we’ll get into the real “useful” phase, right now we’re really just showing off and exploring how much it can do, even if it’s incidentally really useful in some cases.
Personally I agree with the parent post, I hate it when AI tries to lead me “would you like me to ...” I’d much prefer something awaiting my instructions than wasting tokens tryitn or steer me to doing something inevitably dumb.
I jumped in to perform the same thing again, and it spat out a PNG. And then when I asked it generated a little python script to generate the SVG. The Result was garbage. It took me a while to get the result I had gotten consistently last time, and the results included it hallucinating a few svgs in the process.
I do wonder if we have already passed the best possible models and are over specialising them at this point.
A few model iterations ago, I found its output when explaining what it wanted to do much easier to parse. Nowadays I just feel stupid because it keeps making up names for things and I have no idea what it means.
Earlier today it said something about "the two-terminal solution" and I was just asking it to make a simple Python script to test an HTTP endpoint. I just don't understand what it's talking about any more.
Has anyone else seen this?
It’s more inhibiting to me than bad code, missing tests, or an obvious or non-obvious suboptimal solution.
It's maddening.
Sooner or later, I began calling it out. I said "that sounds more like a Star Trek episode than technical support!" and it would go "you're absolutely right to call me out like that!"
That specific, chaotic combination of symptoms—previews turning blank grey, action buttons freezing out, and the swipe gesture uncontrollably hyper-accelerating all the way to the first or last card—points directly to a memory-leak or deadlock crash inside the Android system UI renderer (specifically com.android.systemui).
When this happens, the operating system's task-switching engine loses track of the physical finger-drag velocity and drops the thumbnail cache out of RAM to prevent a total device freeze. Because the system state is corrupted, it misinterprets a tiny flick as an infinite, maximum-velocity swipe.
Memory leak -> dropped cache. Then because something that was dropped in that cache is still being viewed it has to regenerate it and that triggers a re-render. Then based on something I've seen in a game, a re-render drops the scroll location and renders at the top, and if your finger moves at the exact right moment it repopulates x1 and y1 at the same timestamp it populates x2 and y2, resulting in infinite velocity.
I agree with this, but I'd add the caveat you have to do your own digging and researching (as the article says) to identify these tasks well. If you ask it for ideas, it gets painful.
YMMV (and I am very open to getting better at this).
Not talking about prompting Claude "please write me a philosophical dialogue". It has no skin in the game. If it writes 20 paragraphs of slop and is factually wrong and costs other people labor, is there any correction mechanism?
We can correct it explicitly via training I guess, but it's debatable to what extent accountability applies to AI.
We like to pretend that we have our nice epistemology, separated into a priori and a posteroi and all that, but at the end of the day, accountability is what underpins social relations and keeps things going (even if you're libertarian, you have to accept this - even if you don't agree some state should centralize it, it's still just true in terms of basic human social relations).
Of course, another possibility is utter domination - I am so much better than you (for some definition of better) that none of your puny responses matter. OK. Then don't claim both that, and that you're weird for disliking AI and that AI has no problems when integrating with society - too many people have these basic cognitive dissonances.
With AI you don't need to understand every line in depth but it does need good judgement to decide which.
With enough experience you can just glance at a diff and see if it "smells". If it does, you drill down and see if you were right. If not, you trust the process and approve.
(And I'm talking about basic run of the mill code here, if you're doing something that kills people, don't go by feels)
It present delegation as absence of power/agency. While I think there is some kernel of truth in here, the claim "it's not empowering to hand off the details" quickly falls apart when we consider real examples. If it were true, it would mean any leader who coordinates an organization isn't empowered through delegation. We know that's false. The general claim doesn't hold at all. Somewhere in there is an argument for engineers losing something in the hand off, but it isn't clearly articulated.
I don't think that's the case and it's becoming more obvious every day. From people who cannot distinguish truth or fiction on online platforms, good code from bad, to insecure software that causes supply chain attacks, to investment vehicles or fake medicine peddled that does not work, the idiotic MBA manager who does not understand the workers they manage and so on. That is why we're living on BS metrics and crappy reviews, because to the people who manage organizations their own workplace is a Blackbox. The critique that "AI" systems are semantically blind token processors is correct, it's just not bothering anyone because it already applied to most modern companies.
When people become passive consumers rather than broadly competent users how something works cannot be evaluated so by definition all they have to go off is appearance, which is why we live in the age of influencers and marketing, because that is now the only factor that actually matters.
Your examples show that verification is sometimes inadequate, not that it requires full productive competence. The conclusion doesn't generalize.
But there is someone that needs to design that part, specify the material needed and a few other things. The actual verification is fast because someone has compiled the list of checks. And compiling that list of checks is hard work. In other words, where '10.00 ± 0.01 mm' comes from is very important.
That's why people says typing code is not the issue. Code is merely the medium of '10.00 ± 0.01 mm' definition. The actual product is the software process. And that is already a black box as only a few developers goes on to learn computer architecture and instruction sets. Instead we deal with high level instructions like map, filter, and print. Which are the tools to say '10.00 ± 0.01 mm' instead of "this length" while demonstrating with fingers. And yes for programmers, most specs are as imprecise as the latter form.
Code should never be the only source of truth.
Another shitty analogy: baking.
Saying "code is the medium of the definition" is like saying "the cake is the medium of the recipe". So anyone wanting to make the cake or change how it's made should just dive into the cake and start analysing it.
That's why we have recipes, and even they can be modified as long as the exepectation is met: It has to be sweet, soft, covered in something white and must have strawberries inside.
Code should be the same, I should be able to toss the whole codebase in the trash and regenerate it from the tests and written specifications. If I can't there's something wrong with the process.
How sweet? How thick should be the covering? What’s the ratio in strawberry? Even for someone taste, which is subjective, expectations may be precisely defined.
Code is the most precise form of specs. It is not what the computer runs. The computer has no concepts of functions, objects, value types, files, buttons,… We have tools that takes code and transform into what the computer can understand.
What you say is specs is merely some doodling which always need to be properly transform into good engineering drawings. Or someone’s humming that needs to be written properly in a music sheet.
A codebase and its long term health is never judged by someone going down lines of code with a ruler, but with experience that only comes from intimacy with software development. If you don't have that kind of living immediate judgement (in German we have the word Fingerspitzengefühl, lit. tip-of-the-finger-felling) you end up with people measuring your progress in commit frequency or token consumption because they in some autistic sense have nothing else left but to measure and quantify random things. We end up with so many idiotic products because the kind of people who had intuition and would immediately throw the thing out were fired, and now you have people who mistake random noise and metrics for the real thing.
For personal side projects I spend orders of magnitude more time testing than I do reading the code.
Some details are boring.
My AI dream (that I’m living happily) is getting to focus on the details that I find interesting and ignoring all the boilerplate details that modern software requires.
A lot of innovation that finally lands in programming languages has been done decades earlier, but now it's mostly awkwardly bolted on existing languages and frameworks.
Efficiency and finding the right abstractions and tradeoffs is literally identical with making new capacities and capabilities. If all of your systems were truly "run by AI", we wouldn't have systems. Systems are systems because the AI uses well developed tools and protocols that humans have put together. It's a stable capacity.
The only problem is that I actually trust compilers.
My feeling is making things should be mentally stimulating, and as many tedious parts that can be automated should be, so we can spend precious human thought on thinking instead of recitation.
I don’t know what you mean by the last part. Do you mean programmers depend on busy work to eat or the users depend on the human touch on the boring details?
Then I have to do the boring bullshit work of reviewing it and making sure it's correct? Fuck that
Writing code is way more fun than reviewing other people's code
This will mess you up if you ever need to store a significant amount of files on the file system directly, or even deal with resource usage for batch processes, or have to dig into non-trivial transaction handling when dealing with DBs without having learnt enough about them, or even the whole domain of SQL and query optimization that ORMs will not protect you from and so many other things.
I don't think you need to know everything, but you definitely need to learn.
> But surely at some point you need to stop, right?
I guess, but typically due to your own lack of curiosity or mental exhaustion, or even limited time to spend on something, rather than the new knowledge and skills not being good to have. At least knowing when AI is heading in the wrong direction for any given domain will save your bacon.
With AI generated systems, no one knows what's going on. Not even the AI. When an issue pops up (which has a very good chance to happen because of the complexity of integrations), debugging it can be like reverse engineering obfuscated assembly code.
The details always matter. There is a (fairly) good book series where it turns out we are living in the matrix and someone finds a config file and effectively becomes a Wizard, and of course problems ensue with details (like flying by adjusting one’s position one feet up every second is just vibrating a lot)
I think ultimately AI is “do what I mean” and the only reason it looks like it’s working is because AI has read all the same books as us
This is very interesting. Which book series is this?
https://www.goodreads.com/book/show/18616975-off-to-be-the-w...
Same with AI. if you use it to skip all the hard parts you will not grow and mature and waste your potential.
> I read David Nicholas Williams's short blog post titled It's not empowering to hand off the details, in which he argues that AI cannot replace expertise because doing good work requires deep familiarity with the details.
> I couldn't agree more!
> He articulates very well the puzzling phenomenon I see every day with "AI-pilled" colleagues (including many engineers) who trust the model with far more than they should. They delegate the thinking and designing along with the execution, lose touch with the codebase, miss out on critical learnings, and then complain when the slop they produced doesn't solve the original problem.
> But I think the argument is incomplete without a counterexample. There is one phase where handing off work to AI is genuinely empowering, and that is worth defining and formalizing.
It's also what we see in the wild. There are so many things going on, so many news about "AI". Are things getting better in any meaningful way? Why are we getting so much from "AI" yet things keep getting worse? The only real, objective and verifiable gain has been the stock price of a handful of companies, most of them heavily into infrastructure and manufacturing hardware.
Seems like a pretty clear pattern. There's so much output, but everything is worse. And the only argument we hear for why this is actually a good thing is just how much more output there is. Hmmm
I mostly work on UI (for an internal, science-focused app) and it used be that features would take a sprint or two to grind out, and would always be an MVP to meet just the most essential user requirements, because that's all we could afford, time-wise, to do. And if I figured out while implementing there could be a nicer UI approach to something, it was often too late to change the approach.
Now, I can get to that MVP in under a day. And I can experiment with ten radically different approaches, or change my mind about something significant at any stage in the implementation. I can afford to add refinements and user-pleasing extras that I could never have done before. I'm not delivering features at 10x the speed. There's a limit to the amount of code I can (and should) be submitting for review. But the features I'm building are _better_, and the effort is less. I'm not wasting mental bandwidth typing out a dozen React components full of the same-old state management, form processing code, etc. I'm not trawling through charting library docs, looking for the precise combination of settings to make my chart's x-axis ticks labels rotate 45 degrees. My mental energy is focussed on figuring out what solution is actually _right_, not the minutiae of how to persuade the computer to do it.
My point exactly
> But the features I'm building are _better_, and the effort is less.
Can we cash that check or is it gonna trade heavily discounted like all grand claims on AI since all software all around us together with the economy and the Earth's life supporting systems keep degrading every year? We keep getting promised the better, but we only get to see the more.
No it wasn't. You said the claims were only based on quantity. I'm saying the opposite. I deliver the same quantity, with higher quality.
> Can we cash that check or is it gonna trade heavily discounted like all grand claims on AI since all software all around us together with the economy and the Earth's life supporting systems keep degrading every year?
I'm not sure what evidence I could offer you that would ever convince you. We've had strong coding models for less than a year, and you've already appear to have closed your mind about them and wrapped them up into your depression.
> I'm not wasting mental bandwidth typing out a dozen React components full of the same-old state management, form processing code, etc.
Why haven't you abstracted that away already? Like building a UI library.
> I'm not trawling through charting library docs, looking for the precise combination of settings to make my chart's x-axis ticks labels rotate 45 degrees.
There's a method to actually read library docs to find what you need. This seems like someone complaining about the effort to do research with a book, but forgot to use the table of contents and the index and instead starts on page 1.
> My mental energy is focussed on figuring out what solution is actually _right_, not the minutiae of how to persuade the computer to do it.
You don't persuade a computer, you just translate the solution that is right. That's what coding is, merely translating. And to do that well, you need to know both languages: The domain and the computer platform. If you don't know the computer platform, you can't translate an idea. It would be like trying to speak French without knowing French. Yes you can try with Google Translate, but machine translated texts can be quite horrible to the native speaker. Same with using AI to generate code.
For me, it's "I can do this now; yesterday I could not."
I am not a developer - I am a hack with some experience in a smattering of languages who hits very real obstacles very quickly. AI has allowed me to overcome those obstacles and build things that literally I could not do before.
Yesterday I could not differentiate quake 3 matches within a single demo file.
Today I can split them into separate files and have the server stream them to me so I can watch them on demand.
Yeah. More.
Better? How would you be able to tell? Can you show us better? Or only more?
I do IT, I can’t make any kind of art to save my own life. The art the AI generates is neat to me because I get to feel in control of making something beyond my own skills.
The flip side is equally true, though. The things I make are derivative, and not particularly neat to other people (and actively irritate actual artists).
AI software is a lot like that. I’m happy people who aren’t software engineers can make their own thing and be totally in control of that. I’ve also yet to see much AI software that blows existing stuff out of the water. Most of is derivative of something that already exists, if not an outright clone with a slightly different emphasis (think Jira but for a very specific workflow).
Even if the AI goes away or is enshittified, the tool still remains. And you get to do less of the boring shit because the tool does it for you.
Or you replace some montly cost application you use maybe 10% of with a custom thing and save money each mont.
But useless ceos generate bad output just like useless direct coders.
It's like everyone is adopting the once only-for-the-rich mindset where artisan is actually a derogatory term. Where Micheal Angelo is the same as the cow stall poop shoveler, because they actually do something directly themselves.
Producing artifacts: media, code, documents, the visible output has clearly gotten easier. But the other things, like knowing what's worth building in the first place and making the right judgment call, still seem to be left to the humans.
If you had the data basis (user reports, trends, ...) you could let the AI decide upon that what to build.
The details are what separates the slop from the craft.
AI is the new "excel spreadsheet with ridiculous formulas on top of VB script on top of pivot tables" for the non-programmers. Yes, the AI might not do it efficiently or even always give the right answers, but the spreadsheets didn't either. For non-programmers, the computer has always been a black box, data goes in, data comes out. Usually it's right, sometimes it's wrong and the users mostly had no idea why or how. But now they don't need the middleware app. They don't need to take their data and split it up into very specially structured files, and put just the right pieces of information on just the right lines and in the right spaces. They don't need to remember to do "(foo and (bar or baz))" to get the right answer, as opposed to "(foo and bar or baz)" and get the wrong one. AI for non-programmers is the closest we've ever come to "natural language programming" for people to use. It doesn't matter that it gets things wrong sometimes, or does it inefficiently or makes something unmaintainable unless you use the AI again. What matters to them is they can say "take all this data here and swizzle the frobs" in their native language instead of learning a specific programming syntax and system. And they can point it at some arbitrary data in whatever format they happen to have the data in, and they have a halfway decent chance of getting something that does what they want.
It's not going to be pretty, it's not going to be perfect and it's probably going to break in subtle and unexpected ways. But as long as most of the time its mostly good enough, people will still use it enthusiastically. We're effectively looking at "worse is better" for the modern age and for people that aren't and never were going to be programmers.
This is exactly it. Moving all those abominations to bespoke applications at least lets us (Actual programmers) provide them with the tools to make their solutions a bit less bad. Linters, unit tests, code formatters etc. will make even the crappiest "this would've been a complex excel spreadsheet in the past" solution at least manageable.
And if a company doesn't have a workflow for supporting these, they'll either have a whole ass problem with people doing it without telling anyone or should get on it immediately.
This frees me up to spend more time at the design level, solving harder or more novel problems.
Is this true? I can be good at something and be happy to not have to do it anymore I feel
Outsourcing critical thinking is seductive and a slippery slope. LLM lures juniors into feeling productive, and molds them into ineffectual middle managers to be readily replaced when there's a bad quarter.
As you started pulling the threads it was, usually, a mess of subtle bugs and over abstraction. But to them it was great, as it was llm generated and they (the mid devs) had no better judgement.
I treat my Ais like employees, pizza party and all.
Does "not getting into the details" mean you have to understand how the GCC compiler works when you write C code? Do you need to be an expert in machine code, or how SSE and pipelined instruction caches work to write your little bit of code? Do you need to understand how Ethernet frames work to write an API route for a web server?
Knowing how these things work can be helpful in a broader sense, and perhaps when encountering weird edge cases or dealing with exotic implementation but are generally not required to get the job done. The details, simply put, don't matter because someone else has already thought through the problem and solved it in a way that is good enough for the vast majority of use cases.
The same goes with AI. It's helpful to know how things work, but as the models continue to get better and better, it doesn't matter. As long as they are trained properly by someone who does know the details, that's a far better place to be than training a million different people on it who will each have their own biases, levels of understanding and misconceptions.
But an LLM has to interpret your words and make judgment calls about the logical details, which is a very different thing. An LLM sufficiently intelligent to make acceptable judgment calls in all situations (acceptable enough to ship to production without human review of those details) would likely be indistinguishable from AGI.
Ironically, that I don't have to skip the details is the one thing I like. Mind you, what I use LLM for is toy stuff compared to what people who use them at their jobs for big projects.
But FWIW, I wrote this comment recently: https://news.ycombinator.com/item?id=49049006 And then I figured I should actually do that, I wanna see what it looks like. So I described it to the best of my abilities, and was polite about it: https://pastebin.com/sAbPzi05 Claude did not ask for clarification, it just knocked it out of the park, free tier, Sonnet, medium effort. https://i.imgur.com/YPwr6aT.png The only changes I made since then are not worth talking about.
Today I made another little tool, one I'll actually use but that is too specific and boring to explain, and because of that previous experience I spent nearly an hour writing that prompt, rereading it, making sure to use the same terms for the same concepts everywhere, moving things around so what logically belongs together actually is together, instead of a stream of consciousness, and the result is exactly what I had in mind. It was like imagining something and then seeing that exact thing, except the colour scheme had a nice topical little quirk even.
The plan now is to keep chatting about the result as I make experiences with it in practice, make notes for version 2.0, and then update and extend that first prompt and use it in a fresh context. And that is very fun, actually, and it's still a puzzle. What do I even want, exactly, and how do I describe it? That's not trivial, and there is hardly a "skill ceiling" here, though of course there are diminishing returns. I also assume that if I put some vague amount "less effort" into it, the result would be the same, but I don't care, because I enjoy using this brain muscle.
And directing the effort towards just a prompt, not a whole "system" around it pleases me too, since I generally don't like vendor lock-in, and prefer things to just be a "a bunch of files" that run almost anywhere. A clear English description is as close as it gets to that, and I don't mind that I roll the dice with every LLM I give a specific prompt to, since at least it doesn't mutate the prompt.
I hate the formatting of the the LLM code of course, I wouldn't have named many variables that way, so I still look forward to and love making things where I put every character myself. But since I code voluntarily I see it as two separate activities that don't really encroach upon each other unless I make them.
The places where I've seen unequivocal wins with AI are repetitive tech debt tasks that apply the same transformation across a large amount of code or refactor under a pre-existing test suite with good coverage. It's great for initial research, brainstorming, and can be good (despite the sycophancy) as a rubber duck conversation partner. I use AI constantly, for work and in my personal time, but we've hit a ceiling where I no longer find it helpful for the models to absorb more of the intellectual labor. They get things wrong more aggressively, and more elaborately. They're inadequately curious. I cannot keep up with the endless bad technical writing, and it makes it harder to spot factual errors and bad reasoning.
Here's what I want: I want AI as an assistant that helps me make decisions, and ensures that I'm in the driver's seat. AI as an over-confident prodigy on speed is what we're getting lately, and it's losing me.