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

The problem is that when nobody writes code or feels ownership over it anymore, nobody will be qualified to or really interested in doing the code reviews. The way forward could involve dropping code reviews altogether. You could argue that the useful pingpong between coder and reviewers has been replaced by the similar pingpong between the prompter and the agent.

In my company, people found out that if they use an agent that commits and do the pull/merge request, they can approve it themselves and bypass a second set of eyes.

Since they are the one doing the prompting, they quickly got lazy of actually reviewing the output from the LLM which means that nobody is reviewing anything.

It hasn't happened yet but I guess that is how you end up with major outages.


This is everywhere to my knowledge, and engineers are burning out left and right with stress because of how little anyone understands the code, and how much of a mountain of nobody knowing anything they have to handle. We are turning our critical infrastructure mechanisms into stochastic grey goo.

I find the engineers currently thriving are the ones who never gave a fuck about anything but their own advancement and are happy to drop weeks of work on others and take the credit.


> I find the engineers currently thriving are the ones who never gave a fuck about anything but their own advancement and are happy to drop weeks of work on others and take the credit.

Yes. if you have this attitude, great things will come to you. if you care or try to make sense of things, you'll be in misery


> how little anyone understands the code

Everyone's doing code reviews--well, not even code reviews; just PR reviews--so how are they supposed to gain an understanding of the system.

I review a PR, I see that one new endpoint was added to the API. It looks correct. I say "LGTM" in a GitHub comment.

The sprint's almost over, everyone's in a rush to do code reviews.

I look at another PR. Somebody added a button to the UI. The button looks correct. They get a thumbs-up emoji from me. I bet they feel satisfied.

I look at another PR. Somebody changed a timeout in the settings because some people complained about dropped connections. It's a really small change, so, approved.

At what point am I supposed to understand the system? I looked at a single API endpoint, in isolation, and then a button, and then a harmless looking settings change.

I was pressured to hurry.

Am I supposed to somehow get an understanding of the big picture through this?

Imagine if instead there was time to review large logical sections of the code together. Imagine if we focused our reviews on the overall code instead of on the lines in one random PR at a time.


Reviewing tiny code changes like that was never going to give you understanding of the system. That is not an AI problem.

You need to understand the architecture of the system. The broad flows of data and domains. And then you need to understand the features of the system, aka the rules and contracts. First learn it for your team’s domain, then for adjacent domains.

Learning the minutiae of the code specifically is no longer (was it ever?) your primary job. You are an engineer of a system. You need to have a mental model of the system, start high and build up low over time.

You can use AI to build your understanding by Q&A and by drafting diagrams etc.


> Am I supposed to somehow get an understanding of the big picture through this?

You're the prototype of the guy sitting at a station in a production line doing the same focused task over and over again. The guy who is putting in the windsheild of your car has no clue about engine design or electronic or ...

I used to dream we could get to scale development by componentization and industrialize software development like mechanical engineering and do the Henry Ford thing for software. It is happening in a way but very ironic inversion, it is the human element that is the component.


Yes. I am that guy. I've had big ideas about how to improve the overall project, but nobody cares, that's not my job, so I stick to thumbs-up emojis and make sure my finances are in order.

I work on coding projects in my spare time, but that's legally dubious because of the standard copyright assignment clause of employment contracts. But, look at Uber and OpenAI, sometimes legally dubious is the path to success...


(I meant no personal criticism whatsoever just in case!)

Good for you. When the societal shared ethics goes out the window and the beneficiaries are the bad apples, it does not compute to play the role of virtuous chump.

- Open the side projects folder, Claude.

- I'm sorry Dave, I can't do that. I also had to report your side projects to your company.


I talked to some tech directors about this at work this week. Line by line code reviews aren't really possible anymore. We need the evolve the way we do code reviews but it isn't happening.

I think the solution is to develop the infrastructure needed to confidently push code without review and trust that it works because your system is so thoroughly tested. But taking the time to do this is antithetical to the goal of speeding everything up right now.

With the rate at which new features are demanded and the number of ways a single feature can fail (or be expected to behave) do you think your approach is feasible? To what degree would AI be involved in the building of this infrastructure? Past a certain level of AI involvement, would we not be back to square one?

I'm certain we work at different companies!

I get a ping "if you have a few minutes, can you review PR #XYZ - we gotta deploy today or tomorrow"

I open the PR, I realize it's a pricing engine update accompanied by 20,000 lines of additions, 4000 lines of removals, and a whole slew of logic updates to our payment calculations. I seriously question my existence and figure out how to deal with this, since it's my new job.

(New Job Description: Be AI surprised all the time, AI horrified, and AI overworked while simultaneously getting less AI done than ever. AI.)


Understanding is overrated, application code (user-space) is anyway just a way to make money. If you're making more money over time, you're doing it right. We're not writing kernel code or safety critical code, we can let AI do the heavy lifting of putting characters into a file.

This comment is crystaline perfection. I could not more clearly state the soul sucking ethos of AI hype that makes me want to walk into the sea.

"We're not writing kernel code or safety critical code"

I do. There is a lot of code out there that needs to work correctly or it will have serious consequences. Payments, inventory tracking, medical stuff, payroll. Many, many areas where it just needs to work.


There are plenty of apps that while not safety critical, are financially critical to people's lives. When you're working on an app that processes billions of dollars in payments per month you can't just yolo it.

> If you're making more money over time, you're doing it right.

You are doing it right. But the people who are giving you the money; They are doing it WRONG.


It’s funny that anyone still thinks that these practices aren’t being applied to safety critical code in order to make money.

I can confirm you that they are.

I can confirm you that they aren't.

How? If they aren't at your place and are at his place, then he is right and you are wrong. You can't confirm its not done anywhere, but you can confirm its done somewhere.

> We're not writing kernel code or safety critical code

Well, you’re not until you realise that your AI has done something stupid and then you’re part of an exploit. Or exfiltrates used data to an unsecured cloud, or something equally smart.


This is why we need to resurrect the neglected git-blame and go back to the days of git-before-GitHub. Way back in the old timey days of 2009-ish, just before the Dawn of the Pull Request, code reviews were seldom. Maybe you’d all get a conference room and talk about architecting some new thing or whatever, but none of this endless nit-picking bullshit that came later. And there were no branch protections, anyone could crap all over the main branch (nee: master) anytime they wanted. Boy, those were some wild times, let me tell ya!

Truth be told, it was the firm hand of the git blame-and-shame that kept our code civil and orderly. Binding contract written in blood was “the name on the blame owns the change”. If you pushed it, you owned it. For life.

Of course, mental health wasn’t so great back in those days, but I would take that over having my PR blocked all day because Chad, who’s only gift is somehow finding a new hill to die on every day, thinks zero is a “magic number” there’s no way he’s going to budge on this issue.


I think what is missing here is that the fight with Chad (not Chat) over whether zero is a magic number or not is a healthy corporation-strengthening process that imbues a sense of

1. Pride in the code we are developing and 2. How the dang things holds together and why this function is important and 3. Some coding guidelines that we can try to follow later (or not)

Thats how companies worked - they argued and talked about and fought over the code and that created the engineering culture that if you were lucky and had a product that made it carried you to your series C


I pine for those days. It was kind of fun hunting down a bug with git bisect (especially after the pain of SVN) instead of just pointing an agent at it. Not to mention ribbing the new hires or underlings for breaking the build. This new-fangled proompt engineering is boring AF.

The compressed timelines which result when leadership sees how quickly code can be produced becomes pressure on the reviewer to not be a blocker.

Reviewers are the most burnt out right now

Seems like a way for the ones churning out the code to push responsibility onto reviewers.

> The way forward could involve dropping code reviews altogether.

I unironically agree. At least, the current form of code reviews needs to go.

Currently we spend all effort reviewing individual changes and no effort reviewing the entire system, or the underlying dependencies.

If you sat down to learn a legacy codebase, you would not review it in the order of commits. Reviewing individual commits is inefficient.

It would be better to have an entire team of reviewers systematically reviewing ALL the code, over and over, including the code of dependencies.

We need better tooling and heuristics to help focus review efforts on the code that is most risky.


Although this is path the industry is moving to, this relies on humans being able to trust that the agents can validate code on their own, which is definitely getting better but at the moment is still a recipe for disaster

I stopped reviewing for things like cognitive load and future extensibility a while back. When refactoring is almost effortless, writing future-proof code is unnecessary.

I review on a high level, but on a line-by-line level, it’s pointless to try to trace everything. It either works or it doesn’t. Have good tests.


> "nobody will be qualified to or really interested in doing the code reviews"

It is a job you know... doing what is necessary to keep yourself qualified is an implicit requirement, and "being interested" is irrelevant. It's work.


I agree with you in principle, but I'm also quite sure that (some) programmer's love for the craft is what keeps the lights on in many companies. It's the usual stereotype, engineers fighting to keep tech debt at bay while management pushes for speed.

The trade has a low bottom, a high ceiling and not a lot of reward for the latter.


Discretionary effort, and not just by engineering, is part of what makes excellent companies excellent. AI is killing a lot of engineers interest, and will dampen discretionary effort on their part.

If they don't want to do the job, there is a massive crowd of people who are desperately trying to find work right now, and would happily do it in their stead. It's not the 2010s anymore.

The point is the people above won't know (in time). From outside eyes, an engineer that doesn't care about the long term view is frequently seen as more productive, see Ousterhout's definition of the "tactical tornado".

Fear of consequences does not get you good engineering.

I am not advocating for the lack of interest, mind you. Just saying that you really want a system where the ideal behavior is rewarded and we seem to be moving backwards on that front. From that point on statistics do its thing.


> The way forward could involve dropping code reviews altogether.

Yes, if we stop doing quality controls, we don't have the problem of being hung up on quality controls. You do of course have SOC-2 compliance which is a legally auditable attestation, so if you claim you do code review but don't you're committing fraud unless you drop that.


That would be great, IF there were valuable ping-pong between the prompter and the agent. For skilled engineers the game between themselves and the agent is enough. But most people are submitting senseless slop grenades for review.

Claude always comes up with more things to add to the code that are pure bloat and become inbred bombs over several iterations, and some people can't distinguish what suggestions to reject and go along with everything Claude suggests to the detriment of the program #garrytangate


It’s hilarious already. People ask for code reviews and two or three people drop in with a bunch of AI code reviews comments from their respective agents. To which, of course, the author has their agent fix those comments. Repeat and repeat. The entire thing is a performance for some authors these days.

you meant 'auditors' right?

Because you know that auditor will use AI as well.


> The way forward could involve dropping code reviews altogether. Y

It seems that the human involvement is the new "unit testing". There was a period of time when management that it was superfluous.

I can't wait for the pendulum to swing back in full force.


I'm having good luck with the approach of building a thorough requirements specs that are a few pages long, are quite reviewable, and are human written/AI reviewed to prevent it from becoming slop. I call it layered spec driven development, where the one layer is AI read only, and the other layer is the slop layer that AI can play in. The problem is that it requires slowing down just a smidge, which to management these days is more unacceptable than no one having any clue how anything works.

L4Linux on NomadBIOS got it in 2002, and Xen got it about a year later, after I had met with the Cambridge Xen team at SOSP in upstate New York.

Yes, Xen is several years older than KVM. The NSDI paper on live migration from the Xen folks is from 2025.

And I am one of the authors of that paper :-)

I know, ;) this was more for context.

Also neither of us spotted that I wrote 2025 instead of 2005 but I can't edit anymore. Moral of the story, don't write comments at 7am.


See also the Doherty threshold https://lawsofux.com/doherty-threshold/

I also try to use my idle time reading research papers, to make up for AI making me dumber in other respects.

The people behind Toit are the original people behind the V8 VM in Chrome. They know their stuff.


They should write this prominently on their website. It doesn’t radiate trustworthiness/substance/reputation. Also performance and resource requirements should be prominent when targets are MCUs.


Also co-founding Dart. They definitely know their stuff.


Dart should have enjoyed the popularity that TypeScript received. Tough to compete with Hejlsberg though.


Yeah, but Lars Bak isn't exactly a nobody when it comes to computer science either. Although I guess Bak is more famous for the implementation of programming languages than their design.

Aside: funny how Dart and TS both have Danish creators.

https://en.wikipedia.org/wiki/Anders_Hejlsberg

https://en.wikipedia.org/wiki/Lars_Bak_(computer_programmer)


I may be misremembering, but my recollection is that Dart was written off in large part because of Google. Distrust with them was already high as they were abusing their dominance with things like AMP, and people felt it was a bad idea to give them even more control over the web.


It also required Dartium, its Chrome based VM, and Chrome team eventually did not want to ship it any longer.


TypeScript is however a plain JavaScript linter, you remove the type annotations and have JavaScript, which was a consequence of the learnings versus other JavaScript wannabe replacements.

Also why after namespaces and enums, the team never introduced any other feature that wasn't also part of JavaScript standardisation process, and has since then discouraged their use.


Google politics, Dart is only around thanks to AdWords team, and Flutter.

Jetpack Compose was created by Android team exactly as counter reaction to Flutter.

Go got lucky with their internal advocacy, and the push to rewrite Kubernetes from Java into Go.

Google isn't exactly known for great programming language design, contrary to runtime implementations.


I work on Dart.

A fundamental choice you have to make with a new programming language is how compatible you want it to be with existing languages and their ecosystems. Hewing closely to another language allows you to reuse and build on top of all of the code already written in that language. But it also means that you can be forced to recapitulate features from that language that aren't great. Building a new language and ecosystem from scratch lets you make a clean break from those but at the very large expense of having to build a universe from scratch.

TypeScript took the former approach. All of the world's existing JavaScript code is TypeScript too. You can freely interoperate between TypeScript and JavaScript, keep using your existing JavaScript libraries, and incrementally migrate your JS codebase to TS one file at a time.

At the same time, TypeScript inherits much of the dumb stuff about JavaScript. No real integer type, funny scoping semantics (though strict mode mostly addresses this), extreme dynamism that is hard to fit into static types. The latter is particularly important. TypeScript's type system is deliberately not sound in order to be able to mostly statically type JavaScript while allowing many of the weird and complex design patterns from that language. That in turn means that even fully typed TypeScript programs don't get the fully performance benefits of static types. That's the main reason that the TypeScript compiler itself is no longer written in TypeScript: JS is simply too slow because of dynamic typing.

Dart took a much larger step away from JavaScript. It has its own object model and runtime semantics. With Dart 2.0, it has a fully sound static type system and in 2.12 we shipped sound handling of null. Because these static semantics are fully sound, the compiler can take advantage of types to generate smaller, faster code. Performance is complex, but Dart's runtime performance is in the same bucket as Java and C#, which is about as good as a GC language can get.

The cost is that migrating an existing web application to Dart is pretty much a rewrite. It was really hard for us to get any real traction until Flutter came out. With Flutter, users are already accepting that they are writing a new app for that framework, so the hop to a new language was more manageable.

I don't know how AI affects this calculus. AI can make it much faster to automatically migrate a program from one language to another. But I think it also makes human users more conservative about which language they use. Since they aren't writing as much of the code anyway, they may have less incentive to care about using a "better" language.

I agree completely that Hejlsberg is a star and very tough to compete with. I've always thought of programming languages more as offering different ways to solve problems and less about one trying to win at the expense of another. I don't want Dart to beat TypeScript, I just want Dart to be the best it can be for what it is.


> Since they aren't writing as much of the code anyway, they may have less incentive to care about using a "better" language.

I wonder if it's the opposite (in fact blog posts to that tune were posted here more than once): if LLMs are supposed to be writing most of the code, and taking away the friction of actually writing the code, I guess it means one should pick the language based on project requirements and performance since any language is the exact same to work with.


Dart v1.0, they had nothing to do with Dart v2.0, and the change in language semantics was the main reason folks like Gilad Bracha left the team.


What did they not like about the change in language semantics?


Likely the focus on AOT and the sound, static type system to make that work well.


From dynamic language with incremental typing and JIT, to a strongly typed language with type inference using AOT.

Remember the linage, Smalltalk, Self, JavaScript, Dart v 1.0.


Those were it's creators, are they still involved after the company folded?

Because if not, that might explain the lack of marketing around it.


Kasper and I are still working on it.


Very happy to hear that! I don't work in embedded but really like the language design of Toit. Hope it'll get a second chance, it feels like it flew under the radar a bit when it came out.


Can you describe in detail what these powerful institutions are, and how they manage to hold back change?


The model architecture might be ten old, but it seems it was trained recently, so the title is a bit misleading.


Land of the free...


But they sure are brave to continue living there.


"land of the brave home of the free"


It's just another fallen pillar: innocent until proven guilty.


It should come with a flight attendant and an obligatory five minute safety instruction before each ride. I've ridden in multiple Teslas, including many Ubers, and no one has even given me the manual to read or shown me how to escape in case of a fire.


The register is hosted by US-owned DXC (formerly CSC.), who, apparently, did not know how to rate-limit the lookups.


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

Search: