115 comments

[ 3.9 ms ] story [ 18.5 ms ] thread
"Outsource your thinking"

I'm sorry, what?

I am trying to outsource my depression but the market is rough
Why do you think people want to build machines to think for them?
Because they have low self-esteem and demand subjugation for their misdeeds and presumed inadequacy, all of which is perpetuated by a social apparatus that reinforces these beliefs as a matter of business as usual, or, "normal."
I can kinda understand the motivation here: you push a bunch of slop (or is it deep, genius code?) but you have a kind of nagging suspicion that your should get to know it more familiarly, like back ion the good old days a few months back when you sort of understood what was going on. I... don't... think this is going to work...? Remember Confirmation Fatigue? Soon we will have agents that interact with Sphinx for us.
People who care about the problem will definitely not be using this as a method to "understand" their code. People who don't care about this problem will continue to not care.

So, who is this for?

We went from micromanaging code to micromanaging tools and markdowns.
Have you ever heard the idiom "ambulance at the bottom of the cliff"?
I considered doing this with an open source app I have that let's you get a visual summary on a PR + get quizzed on it, but ultimately decided it's better to keep it an optional thing for people that want to understand AI PRs rather than force it as a gate, the volume is slowly become too high for even that. I agree with the sentiment behind this though as I felt this was needed as well.
I mean I see the idea, but at least I use LLMs for code generation in two distinct ways.

The first is when I care about the code. That's when I actually read what it produces and force it to use my mental model of how things should be.

The second is when I just need a solution that sorta fits the requirements provided. Then I don't read the code because I really do not care.

So this hook would either ask me things I know, or it would ask me things I do not care about.

But I guess this is very workflow-dependent.

I think this tool is meant to be something you impose on your colleagues who treat all code like the second bucket.
It’s ironic that all negative comments on here are dismissive because “slop’s baaaaad”. Yes, slop is bad. Carelessness is bad. Lack of understanding is bad. It always has been. Code has been copied from stackoverflow. Built-in methods or std libraries have been used in a wrong way. Edge cases haven’t been covered. Rate-limiting and other hardening tasks haven’t been taken care of until the system broke. The code wasn’t DRY.

Now, people are building tools that not only hide the solutions to these problems in some obscure coding tool, markdown file, or agent harness, but they build gates that help developers to elevate themselves from the darkness of not knowing better. The number of developers roughly doubles every ~3 years, so at any given time, half of the people building software have less than 3 years of experience. Most of them didn’t even study CS before starting their careers. Tools like this will be the new warning voice that told people like us 5 to 10 years ago to never copy code from stackoverflow that you didn’t understand. It’s great.

The problem with AI SE is that AI writes un-architecture-ed code. The problem #2 is that a lot of people suck even more....
> The problem with AI SE is that AI writes un-architecture-ed code

Not necessarily. I use SOTA models with established stacks like .NET which allow my agent to easily follow decades of best practiced patterns (DI, EF Core, ASP.NET Core...) so you still and up with proper architecture.

In fact I can easily still manually inspect everything bc I already know how it's supposed to be written.

The fact that you can say this with a straight face impresses me.
From my experience, the latest models still struggle to create good architecture in the sense of good system design. You mention a couple of generally helpful patterns for the structure of the code. But they don't help much to create logical units, with intuitive boundaries, good cohesion etc. - at which even the latest models constantly make awkward decisions.
> But they don't help much to create logical units, with intuitive boundaries, good cohesion etc.

Completely, 100% agree on these exact points. I have access to every frontier model at work. None of them write what I would call clean code. At work the teams that have gone fully vibe-coded have repos full of broken abstractions that just accumulate over time. Eventually most of the effort of the team and their AI tokens seemingly goes to fixing issues that then break other things. Any attempt at 'refactor this mess, make no mistakes' turns into a _huge_ churn of changes ("shuffling the deck chairs") without ever really fixing things.

Yea but you chose to blame the LLM, not the vibe coders.

As I said: prompting correctly and reviewing are still indispensable skills.

Ofc a big part of it is still knowing how to prompt correctly and manage context.

Perhaps a lot of devs still have a flawed mental model of how these things even work.

I agree, but if we go one step further, what is the goal of those logical units? If the answer is, to make the code more maintainable, then the next question is, for whom? For humans, or for llms? Is it still important that the code is maintainable for humans if no humans read it anymore? Those are not rethorical questions, I am asking them for real. What is "good quality" code in the age of AI? If there is a lot of duplication but no performance consequences, is it really a problem if only AI modify it?
It's fair questions. I think we can see that in lower complexity products, it's already not that important anymore. But I can see that for more complex cases (I'm working on a fairly complex video game for example), the maintainability is currently still important. As the latest models would otherwise still create too many inconsistencies that they can't dig themselves out of. Who knows where we are in 6 to 12 months, though!
Let him who is without sucking among you, suck the first stone.
AI writes unarchitectes code if you don't have a system for developing and maintaining a consistent architecture over time. In human coding, a lot of architecture decisions tend to only live in human brains, communicated through ephemeral means (text chats, voice calls, etc) and are not concretely documented. Since LLMs don't really have a way to manage long running architectural decisions (memory systems can only get so far, like it won't capture architectural decisions if you never talk about architectural decisions), you have to (have your agent) capture architecture design within the repository.

I personally like using openspec for this, because it makes the model iteratively ask you architectual decisions, and then manages creating and accessing the documents as needed.

> AI writes unarchitectes code if you don't have a system for developing and maintaining a consistent architecture over time (...)

I work at a ~15y old codebase; guess that the famous "architecture" is - a glue of half-baked solutions, unfinished ideas and inconsistencies. Recently I discovered there are 6 different ways used to create audit trails in the app. The "human memory" lives until person decided to switch job or is fired. Then the next person re-invents the wheel and cycle continues.

I suggest taking an honest look at "the architecture" people are so proud of - you might realize there is not much moat there after all. But then again - I mostly write cruds - so that's probably core of the problem, lol

So who is the master of whom?
Honestly I love to see people working on this problem ! I actually built a similar project myself (https://github.com/bhurghundii/vibecheck.dev) except it prevents you from merging on the PR level. I’d love to get in touch to talk about it sometime.
Does it check if the answers are AI generated?
Not yet. But you’re like the 5th person to mention it so I think I’ll add that feature. There are some AI prevention stuff like you can’t copy paste which means you gotta use the visualisation.
I also experienced pushback when I shared a similar skill with some of my colleagues (and it didn't mention "vibe" in the name). The main objection was "I am doing careful planning upfront, so I have the same level of understanding of the code as before".

Maybe they do. In my experience, the agent was going over the scenarios that I failed to consider during the planning stage, and it was net positive. I haven't tried it with a spec-driven approach.

I get what they say but what I see or have seen is totally different. I come from an engineering culture where we got AI token leaderboards and mandates to use AI for every single step of the development process. We started running into bad bugs recently due to people just copy pasting the Jira into the prompt so I feel there is space to put some intentionality in the areas which matter.
This is cute and novel, but practically useless. For those who use AI efficiently and effectively, this is useless. For those who don't, this becomes friction they don't want. Who really needs this?
Its the right problem statement, but we normally let the code review process take care of this.
I think this would be killer for OSS maintainers.
force contribs to pass quiz of their changes. really helpful!
I went around and asked a bunch of them with a similar idea (see the above comment of mine), and you'd be surprised to hear that they all hated the idea. They mostly just don't want to deal with anything where they fear that the person vibed the submission. Just no desire to engage with at all, because they've got so many bigger problems with the avalance of code coming their way.
(comment deleted)
(comment deleted)
a tool written by AI (mostly) to check code written by (possibly other) AI.

however, it still feels like a lot of work. what if AI hallucinates during the check?

And then you have review process done by AI as well. The trick is they all need to hallucinate the same thing and if they do, the initial requirements were wrong.

Sun Tzu said: If your people (AI agents) repeatedly fail to follow instructions, examine the clarity of your orders and the effectiveness of your leadership before blaming them.

Lol I built this and immediately got frustrated with it and stopped using it. I think I don't like being questioned by someone who I expect to work like magic.
I certainly feel like certain AI coding practices I have leave me with nothing learned in a frustrating way. Sometimes the most effective way to getting what I want is just describing a goal really clearly, and then bashing the AI until it gets there. That bashing process can take a lot of energy and yet I don’t gain useful skills or a “better way” that I would if I was still coding. I generate more training data for BigAI corp, but that’s a slow return cycle.

Not sure if this is the right solution, but I would like to learn/understand/grow more as I pursue reckless efficiency.

Code by hand? The good old fashioned way? Might be "less efficient", but you will understand what you did and build experience.
Reason #1 to keep writing code by hand is that you don't ever lose that disconnection between you and the code.

There was an excellent post here on HN that unfortunately went unnoticed. I highly recommend reading it as it exactly points out this problem: understanding.

Here is the link: https://news.ycombinator.com/item?id=50128468

Note: The post has now been flagged. Why? I have no idea but it seems incorrect.
Because it's not glazing LLMs.
Flying monkeys, probably. You can email hn@ycombinator.com about unwarranted flagging.
The post generated a mass of low quality comments (show dead). Plus after about a few paragraphs the site posted degenerates into just calling all AI companies liars with no (in-blog) justification.

I thought the flagging was appropriate after I read it.

Learning is the bottleneck for shipping code. Building the model in your head, feeling out the edge cases and system interactions, and understanding the intricacies. Typing out the code is a small part of the process.

So, if you want to speed things up with LLMs, the bulk of the speed comes from reducing learning.

Imo if you’re reprompting you’re losing. If the agent oneshots the task its good but if it doesn’t manage it on the first try you will get there faster by doing it yourself.
Isn't this what /goal was meant for? Claude will bash _itself_ into reaching the goal.
In my experience, it's quite good at deciding on its own that the goal needn't be properly met.

"Goal achieved!" "OK, does it work?" "No."

Humans are now test subjects in the ci pipeline
Whenever I stop for a moment to think about it:

It is absolutely batsh*t crazy insane what SWE has come to in the last cple years.

And yet part of me is loving it.

[flagged]