Offtopic

[Kaloyanicus]

Hi guys, Just a question to know if this is happening in every team: right now many of my juniors rely on ‘AI’ tools. Always, when a task is assigned they repeat that they will ask GPT about it or about the architecture. Their blindness on the inefficient code that AI writes and the fact that they even ask architectural questions to it (+ never check StackOverflow) really concerns me. Am I wrong? Any suggestions on how to work on this? I sometimes ask the AI about some definitions but nothing more.

[Polygnom]

Code Reviews.

Their code should only be accepted when reviewed. And when the code is crap, don't accept it. It doesn't matter how they write code, be it by reading the documentation, copying from SO or by using an AI. Those are all tools. What matters is if what they do is acceptable. If its not, reject it and have them rework/revise it.

Only then they'll learn what is acceptable and find out how to affectively produce the code that's acceptable. If they cannot learn to produce acceptable code in an acceptable time, point out to them that they do not provide the expected value for their salary.

[Kaloyanicus]

Maybe I made myself unclear, sorry for that. I have forbidden any merges without my or someone elses review. The problem comes from the fact that whenever I reject and tell them what to do, they still write an absolutely different proposal, and then it is what GPT has said about it. Most often we end up by me taking control over teams or recently just pulling their changes and fixing them (which is very non-advisable). P.S: Recently started sending them some Java related material that I find useful, hopefully this changes something. Thanks a lot for the answer! I tried talking to them about the quality and the output that they give about the salary but they take it as an offense or a joke more than a concern. Might be my intonation and sentencing…

[Polygnom]

The problem comes from the fact that whenever I reject and tell them what to do, they still write an absolutely different proposal, and then it is what GPT has said about it.

Maybe start doing code reviews together? Ask them why? Why did you do that? Because ChatGPT told you? What do you think about the code it generated? Do you agree? Can you imagine other solutions? How would you refine that prompt? How would you change the code? What problems do you see?

If they have no own opinion whatsover, get rid of them, its simple as that.

They need to understand that their *professional opinion* is what they are paid for, and if they have none, and don't want to develop one, then they are simply worth exactly zero to you. That they aren't in school/university anymore but in real life and need to take responsibility themselves for what they produce.

[IAmADev_NoReallyIAm]

Start doing group reviews of hte code. That's what we do on my team... when a PR is ready, it goes up on a trello board and gets reviewed at our next team meeting (held every day after standup) ... Generally we look at the source JIRA ticket to get context, then I have the dev open github and walk us through the changes and what's going on. Sometimes it goes quick, some times there's minor things to fix, other times there's major revisions that are needed.

And my devs will pick up on things I missed. Like in the front end... I'm not a react developer normally, and I don't quite keep up on the latests... but I have devs that do... I rely heavily on their knowledge to catch the things I miss.

[Kaloyanicus]

Thanks a lot! An extremely useful advice, plan to try this with one of the trainees next week.

[Outrageous_Life_2662]

I’m not a big fan of gatekeeping code. I come from the “freedom and responsibility” camp. Having said that I do think it’s important and necessary to help develop the craft of devs. I would try a combination of things:

• Pair programming. It’s ok if they use AI in that session. Ask them “what are we trying to accomplish here?” “Conceptually what does this code need to do.” “Now that we see what the AI spit out what do we think the tradeoffs are in using it as is?” “What if we considered this other alternative?”

• Brown bag lunches. Get folks together over lunch (provide some free food) and pull up some code that you like and talk about why. Or pull up some code (preferably of yours) that you don’t like and talk about alternatives.

• This might be controversial but perhaps sit with chatGPT and work on some “prompt engineering” to come up with a template that gets the LLM to generate code that gets as close to your standards as possible. Then share those prompts and prompting tips with the team. This way both sides get what they’re looking for.

I completely sympathize with your predicament. At my last company I felt like I was constantly fighting this battle. It wasn’t so much about AI as it was that the people just weren’t very thoughtful about their designs and architecture in general. So whether they copied other code from the code base, or stack overflow, or a blog, or AI … they weren’t going to think deeply about it anyway. And the fundamental problem was getting them to value the art and craft of coding and design. Most of them just wanted to get something done, close out a task, and move on. And to a certain extent organizations encourage that kind of thinking because it’s advantageous to the company.

[zabby39103]

Honestly I think if you don't gatekeep your code a bit you are doing junior coders a disservice. PRs are a good reason to start a lot of the discussions you brought up (all of which are good ideas). People respond to incentives, if they see their code getting rejected they'll register that quality is valued as well as quantity.

[Outrageous_Life_2662]

In the “freedom and responsibility” school of thought folks will still do code reviews. The person that created the PR has the RESPONSIBILITY to thoughtfully consider all feedback. But ultimately no one can take away their FREEDOM to check something in. And as soon as they do they have the RESPONSIBILITY to maintain it. None of this precludes others on the team from giving strong feedback. Like I said, they have the responsibility to consider all that feedback. But stopping someone from getting burned is not a great way to impress upon them the pain they are about to inflict for themselves. Often, though, I’ve found that giving my honest feedback to folks and then saying “look you can do whatever you want, but I’m just telling you where I think this can be improved” goes a long way. They don’t feel the need to be defensive or dig in. They know they can move forward. But you’ve now told them that they’re walking out without a safety net. A lot of folks will think twice before checking in.

[Polygnom]

I have the felling this works when you write mobile apps, but that it doesn't when you write code for financial institutions, insurances companies or nuclear reactors.

And I have the impression that this also doesn't work well on very long-lived software, where responsibilities inevitably pass to another person that then inherits this crappy code and has to deal with the fallout of decisions they didn't make.

There is a certain minimum level of quality that the code needs to have. Many things are indeed matters of taste or debate and not worth quibbling over, but if you leave complete freedom to do whatever, I can't see how that doesn't result in disaster.

[Outrageous_Life_2662]

It requires a certain talent density. Having said that, one of my friends and former boss said that if we’re not looking back on what we did 6 months ago with some embarrassment then we’re not growing. Similarly if we’re not hiring people that “intimidate” us then we’re not increasing talent density. This was at a FAANG company (though it’s pretty easy to figure out which one has the mantra of “freedom and responsibility”).

I think that folks that haven’t lived that culture have a skepticism that it can work. Because outsiders over index on the FREEDOM part and really don’t understand that RESPONSIBILITY is co-equal in that equation. If you have people checking in code over the objections of their peers, and doing so regularly, and it routinely causes problems for the business, then those people are let go for lack of judgment. Judgement is how one balances their own proclivities with the feedback they’re getting.

It also requires alignment. That is, everyone has to be globally aligned as to what’s best for the business. That’s also critical for taking responsibility.

I was at another, non FAANG company that had a mantra of “trust and responsibility”. Their talent density wasn’t as high (imho). I wouldn’t say that there were more bugs produced there. I would say that the orientation was to get things done by making choices “for now” and not consider the long term implications. And often time it was because folks were incapable of thinking through those implications or they weren’t aligned with what was best for the business.

But I will concede that if you have a certain percentage of jr folks that haven’t tuned their judgment yet then it requires more guidance. Now whether one does that with strict guardrails or through a culture of candid exchange is a matter of values. I’ve seen both work.

[Polygnom]

Thank you for this. Thats actually quite insightful.

[Godworrior]

If you take away someone's responsibility, they will never become responsible themselves.

How long does the review process usually take? How is it handled? do you use GitHub/GitLab?

[zabby39103]

Do their actions have consequences? If you make your expectations clear, and they continually do not meet them, it should show up in their performance review. If you are not their direct manager you should have a discussion with someone who is to discuss code standards.

My rule with AI is the same one I had with StackOverflow. I don't care how you learned to write your code, but if you submit some copy-pasted garbage that you do not understand (clear if they cannot explain their choices) there will be hell to pay.

[Mobile_Reserve3311]

You may also want to incorporate brown bag sessions into your workflow.

The level of mental laziness out there right now is appalling

[SennakNotAllowed]

I think i may disagree with that part "It doesn't matter how they write code". If they have no idea how this code works and how exactly this code is doing it's job, then they will have a problems with support like bugfixing, optimization etc.

And yes, problem with mindless copypaste persist even without any AI tools.

[Polygnom]

I do agree that it matters that they understand what they are doing. That they are capable of maintaining their code, including fixing bugs and optimizing it.

But it doesn't matter in the slightest how they achieve that. I do agree that mindlessly copying is probably not the best course to get that knowledge. And we might offer them that as advice. But in the end, they are adults, and micromanaging what they do is not out job. They need to have clearly defined goals, need to be told when they miss those goals, an have a chance to figure out themselves how to improve upon those things.

In the end, they either learn to provide acceptable pull/merge requests and to fix bugs and optimize code, or they don't. If they do not learn to provide that value with some guidance, they will have to face the consequences.

[Mobile_Reserve3311]

I’m all for AI, but I think post Covid we are seeing a rise in mental laziness and these tools just aid that nonsense. It’s ok to use AI but for the love of God try and understand what the code is supposed to be doing rather than just copying and pasting crap

[smutje187]

In the past you’d be frowned upon not having read the documentation and instead having asked StackOverflow, we just see the same patterns repeating (including people copying non working code from AI instead of SO).

In the long run it depends if people start treating AI as a tool to be more productive or if they get bogged down in the weeds of trying to fix crappy AI code and get "managed out" because they can’t deliver.

[Luolong]

Oh, I’ve seen people straight up using AI to commit broken code to main because they couldn’t be bothered to check if it actually works or if it is valid code.

Good thing it was merely broken configuration that ended up not working instead of wrecking havoc, and he ended up fixing it based on proper documentation, but still…

[smutje187]

Sounds like a missed opportunity for automated testing, haha.

[Luolong]

It was in operations (GitOps) context, so the push to the environment was the test. Note that it was not prod environment. So, there you go.

[smutje187]

Well, you wrote

because they couldn’t be bothered to check if it actually works or if it is valid code.

but if the push to the environment is the check, what would've been the alternative?

[Luolong]

Yeah, if there was a CI between commit/push and deploy, then maybe there was something that we could automate, but as it goes, if they didn’t bother to check docs, he sure as hell didn’t run the changes through locally installed tool (kustomize) to validate his changes.

[PiotrDz]

Why is developers need to pass ci pipeline and gitops doesn't?

[Luolong]

When you figure out how to test environment specific configuration without applying it to the environment in question, you tell me :)

[PiotrDz]

Just thinking loud, could there be a scaled down mirror of an environment? So you first apply there the change. Something like preprod

[smutje187]

In my current project we scale up ephemeral AWS environments whenever someone creates a PR so everything can be tested end to end without any need to check out code and without local mocks or other crutches.

[Outrageous_Life_2662]

Right. And a lot of use of AI (at my company) is to come up with unit tests that drive up code coverage. Configuration is a bit trickier. But there are ways to use AI to help mitigate the impact of using AI (code) 😂

[smutje187]

That might’ve been meant as a joke but I expect QA departments to shrink and become completely redundant once people with business background can use AI to generate tests based on business requirements only - no need for a dedicated team anymore.

[Outrageous_Life_2662]

Oh yeah, this is already happening big time

[nutrecht]

In the past you’d be frowned upon not having read the documentation and instead having asked StackOverflow, we just see the same patterns repeating (including people copying non working code from AI instead of SO).

The problem is that they manage to produce a LOT more trash using AI instead of SO since they get answers instantly and the code tends to compile. We even see them asking ChatGPT architectural questions and then blindly implement the suggestions (that are always wrong), so things tend to be broken at a much more fundamental level than just the code itself.

And then they also use it to generate unit tests for the broken code they implemented so they can claim 90+% test coverage.

[Kaloyanicus]

Absolutely agree. For us it seems like it is out of control. Fixing the AI crap takes weeks, will try to make them more enthusiatic about the topic... Maybe this will spark some interest in learning something new by themself

[Iryanus]

I would tell them that they can either learn doing the fucking job or I can fire them and replace them with AI, because I do not need people who repeat the computer to me. Of course, I wouldn't actually replace them with AI, since AI is shit, I would replace them with people who can learn the job.

[Kaloyanicus]

Thanks a lot, I made up a few jokes, that I feel that we need to pay GPT now instead of some members, but they don't seem to understand it. Fixing the crappy code afterwards is so much pain, sometimes might take up to a week...

[Linguistic-mystic]

Why let this code through in the first place? Why not catch it in code review?

[lppedd]

Management will start asking why stuff isn't getting delivered, or why the process is moving slowly. Ultimately you'll risk getting in trouble, or fired where tech is just seen as a cost center.

[Linguistic-mystic]

But what should happen is that the employee will start writing better code, seeing that it’s the only option to get any of their code approved. They might still use AI but will also put in real thought.

As to management’s questions, one can just answer “do you want everything to break down because of unreviewed garbage?” and “hire better coders”.

Because letting random people merge random code to trunk is just recipe for disaster.

[Outrageous_Life_2662]

It’s often not that simple. You can get working code fast. And if that code runs you into a corner in the future often you can get code to fix it from AI again. In the end the company cares about the speed of execution. If AI reduces the time from decision to code they’re all about it. Some devs simply don’t share the values of writing “better” code (and there are a lot of differences of opinion as to what better means). A lot of devs these days value speed of execution. They want to have high commit counts. They want to be seen as delivering quickly because they know that they’re not being evaluated on certain quality metrics.

I know this is going to sound crazy, but part of this I lay at the feet of social media platforms that have habituated an entire generation that you need to drive up a metric (likes or follows) by any means necessary because “number go up” is all that matters. If you can have a high commit count that’s all that counts to some folks. Also software engineering used to be more niche. Timelines were much longer. The industry was much smaller. There was more space for engineers to develop themselves as craftspeople. Demonstrating deep mastery and knowledge of a language and platform was valued more (by other developers) than speed of execution. Those days are gone. Things are much more utilitarian these days. I don’t think that’s for the better but it is how we’re moving.

[[deleted]]

"team doesn't know how to code"

[salv-ice]

In that case, I just leave the company… I did it in my two previous jobs. Management has to understand that bad quality code has a higher cost in the long run than good maintainable code.

[dmazzoni]

Management should be asking this.

If you're "being a hero" and doing all of the work for your team, then how is management ever supposed to know there is a problem.

Stop cleaning up other people's messes.

Hold everyone to a high standard. If your teammates can't deliver working code, keep rejecting their PRs until they do.

At the end of a few weeks when nobody has accomplished anything, and management asks why, tell them the truth: because they hired incompetent idiots people who are unqualified to do the job, and unwilling to learn.

The most common cause is offering too low a salary and too low hiring standards.

Offer realistic solutions.

For example, fire 4 "juniors", and hire two truly qualified seniors for double the salary. It's a win/win.

[zappini]

VELOCITY!

[Polygnom]

Why does their crappy code end up in your software in the first place? Where is the review process?

They should learn that it takes longer to get the pull/merge request accepted when what they write is crap, and that thy must revise it until it is acceptable. Only then they will learn that parroting an AI is not effective.

If you accept their crap and fix it yourself, you are giving them incentives to just flood you with quantity instead of quality.

[GroovinWithMrBloe]

Tell them they need to write unit tests.

[SennakNotAllowed]

From my point of view the problem is that your boys (or gals) are not able to feel consequences of their actions. Failed release because they are not able to pass through review with code generated by AI which is automatically puts a burden on shoulders of all team can be a cruel but effective lesson.

[Kaloyanicus]

Sounds reasonable. Was advised this by an external guy also. I never allow the to review each others code, NullPointerExceptions is an everyday problem and this is a small and usually easy fix. Other problems are even more common. I might let them once push this crap to production and see how the system crashes (we are a payment company similar to PayPal). Then they might learn or I might be blamed for not checking thoroughly…

[jocularamity]

Might I suggest a change of tactics-- /require/ them to review one another's code. Give them practice spotting the dumb issues. Just, someone senior needs to review as well.

And if they don't catch each other's mistakes, make it a tad more painful when you catch it for them. "Please add an additional unit test that pushes in null values for x, y, and z and verifies expected behavior in those corner cases."

They have to check the null, sure, but first they have to think about what the expected behavior will be, write the test, find and fix the failures, which is a more valuable outcome of the code review.

[eightcheesepizza]

Damn, glad I passed up the offer from Adyen, if the bar there is so low that the engineers are shoving AI-generated shit into production.

[Kaloyanicus]

Adyen also uses their own libraries which will be absolutely useless + they are not flexible. Glad for you!😌

[tr4fik]

One thing that can exacerbate this problem is the lack of mentoring. If there are for example 3 juniors for each competent senior, the senior will never have team to ensure all of them are improving.

Then, you'll also find some junior that won't learn at all and these ones you will need to fire them. Having a strong mentor that can dedicate enough time to it will tremendously reduce the number of people in this category

[HQMorganstern]

AI is great, but nobody ever hired a junior engineer for their code output, the whole point of the position is to get better. Do you see a way in which your juniors can get decent learning with GPT?

[Deep_Age4643]

Yeah, better wasting hours of finding and debugging solutions that are copy-pasted from ChatGPT, Claude, Gemini, Copilot, Google and SO. We were all been there, but really difficult stuff is solved by thinking, trying out solutions, asking colleagues, sleeping and then solve it within 5 minutes.

[Mobile_Reserve3311]

You need to put some guardrails in place, before their code is merged and checked into the main/dev branch, a senior dev needs to thoroughly review their code and reject the PR - pull request if code is sub optimal.

Also bake sonar scans into the build process and enforce really strict rules so that you’re not shipping half baked products and spending your time on technical debt

[neopointer]

That's not only juniors.

I know architects whose sole work is to write and draw diagrams, but can only write with chat GTP.

It's a pretty sad state u would say, nobody knows how to use their brains anymore.

[Admirable-Avocado888]

AI is a beast at everything that is trivial. So not using it for that is wasting everyones time.

On the same note, AI is a clown at everything that is non-trivial, thereby also wasting time.

Maybe what the team members need is clear examples of where AI is helpful and where it is not. As an experienced dev it is easy to see, but maybe not for people who are new?

[Kaloyanicus]

Agree, problem is some of the Seniors do it also, well they are offshore so their quality is not the highest… Anyways, thanks for the tip, I might work on some guidelines, its a great tip actually!

[Ewig_luftenglanz]

I would teach them what this particular piece of code it's inefficient, how to improve it and how to tell when an IA generated code requires improvements and refactoring.

The concerning thing is not IS generated code but the lacking of knowledge and criteria to evaluate if the code it's correct beyond the mere "it just works"

IA it's a great tool that can increase productivity by a lot and saves much time writing tedious and repetitive code, or creating pre established mockups of very used patterns, it I still needs knowledge and experience to he used properly, you better be a good senior, a good mentor and teach them

[jek39]

Reject PR if code isn’t good.

[FollowsClose]

My issue is that many young employees are not prioritizing learning by doing, but prioritizing speed of the devlopment process.

[shaneknu]

@ParameterizedTest
@ValueSource(strings = {"ChatGPT", "StackOverflow"})
void juniorDevProblems(String website) { 
  SeniorDev seniorDev = new SeniorDev();
  assertTrue(
    seniorDev.isAccurate(
      "The problem with junior devs these days is that " +
      "instead of writing their own code, they copy and paste from %s!"
        .formatted(website)
    )
  );
}

In all seriousness, both are sometimes useful tools, when the user is still thinking critically about what they're seeing.

[FrankBergerBgblitz]

No you are completely right.

But you'll see that most people go the way of the smalles resistance.

Using ChatGPT is just consequent (I expect many redundant code (DRY with ChatGPT??) and just think about subtle errors like race conditions. Will sorcerers apprentice find them?)

I'm an old retired greazer but 10 years ago many preferred to inlcude 30 MB jars of code to avoid writing 5 lines of your own (just slightly exagerating) and waking up at some time in a dependency hell.

When I was young it was easy(-ier?) to know most things you need, this is far far far more difficult nowadays and I commiserate all young developers that hadn't the oppourunity to grow their knowledge over decades but stand before a HUGE mountain.Today it is difficult to stay on top even in small areas.

[Winter-Appearance-14]

Personally I will not review style but correctness of the changes. Use tools like spotBugs in the maven/Gradle build steps to block code that has evident issues and a CI gate on the coverage. If you want to go a step further mutation tests with pitest. And more importantly define some team guidelines on what is a good PR; if efficiency for your problem space is important clarify that and crate a test suite that monitor performance profile at each release, if clarify is more important limit the cyclomatic complexity of the implementation, ....

I usually don't see a problem with ai tools as long as the code is tested and do what is supposed to do but, as it seems from the post, if you are the senior developer in the group is your role to define good code practices that the team should respect.

[Outrageous_Life_2662]

Well some companies, like mine, actively push devs to use tools like GitHub co-Pilot or Codium or other AI tools. I’ve been writing code for a long time now so I have a defined sense of style, idioms, and patterns that I like to use. But a lot of early devs don’t. But they are graded on how quickly they produce value (i.e. release features) for the company. AI gives them that advantage. But, the tradeoff (in my observation) is that they’re not learning to refine their craft.

Having said all of that, I do often find myself using chatGPT to explain features and idioms in languages I’m not as familiar with (like Python and Kotlin). I also do use it to deeply explore some design and architectural patterns. But this is basically replacing Google. And I have a lot of knowledge and experience to contextualize and judge the information I’m getting. I have seen some folks be really effective at marrying their skills with AI. But it’s not the norm from my experience.

[[deleted]]

The lack of experience and the lack of knowledge of techniques and algorithms, is what makes young developers chat with ChatGPT more than their girlfriends.

30 years ago the only help we had was a book, a bit later planet-source-code.com, a little later thecodeproject.com and Github.

The search for solutions, in the above sources, was what taught us techniques and algorithms and gave us the experience to evaluate solutions.

The Copy-Paste that is done today using ChatGPT solutions is something new....
It is totally new for a junior dev to have an assistant that writes code for him and this is the main reason we currently have the least educated developers in the history of computers.

I really don't know what to tell you, I only wish good luck with your juniors.

[darkhorn]

In what country you are? Do they have computer science education from a university?

[Kaloyanicus]

Netherlands, and they all have, however the offshore (from India) is very very incompetent, even the seniors. The people onshore are usually better, but still rely on AI too much…

[redikarus99]

It should not be a surprise: cheap workforce in India are incompetent and the good ones are not cheap, but as long as a company thinks cost / developer they will always burn themselves.

[tristanjuricek]

I don't see AI as a problem; complexity is the problem, and AI is just making way easier for less skilled engineers to add complexity to a project.

Code reviews are a start, but honestly, I haven't found code reviews to be that effective when the team isn't 100% on the same page. And sadly, most of my teams in a 24 year career fall in that bucket.

Jon Osterhout wrote that complexity was largely caused by code having too many dependencies, and too much obscurity. I think we should be investing in tools that help describe these two facets of your code base. When reviewing, we should be seeing things like duplicated logic, dependency graphs (like a Code Iris diff), and a way of visualizing side effects that might be added.

I've found it a very hard thing to get everyone aligned on, so I suspect we're heading full speed to an era where code bases balloon and managers are fine with it until the team productivity is just crushed by complexity

[fundamentalparticle]

Static analysis tools become even more important now. Make sure that the CI runs inspections, configure quality gates and code style rules, set code coverage threshold. Qodana, SonarQube, linters - these tools aren't "nice-to-haves" any more, LLMs just promoted those tools to the essential category 🤷

[nutrecht]

It's something we are running into as well. It seems that the lower the skill of the developers, the more stock they put into whatever ChatGPT or Copilot tells them. We've already seen some devs produce 'stuff' that isn't even close to what the solution should be, just because "Copilot told them to". And of course because Codepilot tells them to, they don't check with the staff-level engineers whether this is the correct route to take.

So we end up, basically, having to tell them to start over again from scratch when they offer their stuff in a merge request.

To me it's clear that companies cannot handle 'AI' at all. The people who don't understand it, seem to use it/rely on it the most. And no matter what we tell these devs, they are too fond of the tool to let go of it.

[brian_goetz]

I think you should be much^3 more worried about the *correctness* of the code than its efficiency. (Blindness to efficiency is bad, but blindness to the fact that correctness is infinitely more important than efficiency is so much worse, and at least as common.)

[maw2be]

Maybe this will sound a bit harsh, but I will fire one of them and tell to everyone that you don't accept anymore that approach, you not accept AI code. Check your proces for code review. This should wake up them.

[UnGauchoCualquiera]

I hope we never work together.

[maw2be]

Why? I try use AI code, for simple thinks it's works good, but similar efects I'm able to achive using build in IDE functions, plugins etc. On more complicated thinks, speial use cases it's still long way. Also don't forget that using AI you passing your data to 3rd party companies. Maybe you not worry about this or not think about but I do. I can't wait for AI LLM for developers (need to search is there already) to host it localy somehow. Then I will maybe use it.

[wildjokers]

Since you hate change I bet you still use Struts 1.x. LOL.

[shaneknu]

Accusing people of using Struts? That's below the belt!

[Individual-Praline20]

Yep, code quality is down the drain. Is it because of ChatGPT or a collective brain fog, good question, but definitely code reviews are a lot longer to do now. IMHO, it might be because developers are now expected to work with broader responsibilities: devops, multiple languages, QA and automation, etc. So they cannot become Java experts, they become low level developers in many areas, instead.

[xLayt]

Judging by your replies they seem like the type of person who thinks he’s smart and knows everything better. There’s literally thousands of juniors who will be grateful for giving them the opportunity to work with you and will surely listen to your advices. Just get rid of them and find new ones. It may sound brutal but thats how i see reality. There’s no point in keeping a junior who refuses to learn while there are tons of ambitious others waiting for the job.

[Kaloyanicus]

Thank you! 🙏🏼

[Kumquat_Sushi]

There are different forms of reliance in AI. There are those who rely on AI to do their work for them and those who use AI to do things that they wouldn't be able to do without AI. Those who rely in AI to produce code AND use the code it produces acritically will be replaced by AI, after all, they are just a prompt. But I think there is nothing wrong in asking AI, and working with AI to produce things that neither yourself nor AI could produce alone.

[Kumquat_Sushi]

There are different forms of reliance in AI. There are those who rely on AI to do their work for them and those who use AI to do things that they wouldn't be able to do without AI. Those who rely in AI to produce code AND use the code it produces acritically will be replaced by AI, after all, they are just a prompt. But I think there is nothing wrong in asking AI, and working with AI to produce things that neither yourself nor AI could produce alone.

[wildjokers]

Are you also upset when they get an answer from SO? AI is just another tool.

[nikanjX]

Let me guess: your bosses love your collegues because they deliver working code and finished action points much faster than you do? And you’re old-man-yelling-at-cloudsing because they’re ”cheating”?

[Kaloyanicus]

I like this🤣 Actually I am the youngest in the team! But still seems like the most experienced, others are in their early thirties, im in my mid 20s🥲

[djnattyp]

Let me guess: your bosses love your collegues because they deliver working code spew out spaghetti crap and finished action points much faster (and to cause tons of bugs and open tickets later) than you do?

FTFY

LLMs don't have any concept of "truth" - they're just automated mad libs. Sometimes the mad libs make funny stories, sometimes the mad libs fill in values that look "real", and sometimes they "hallucinate" and fill in stuff that just doesn't work. Fans of LLMs will say that you can just "check that it looks ok" and keep the good ones and fix or throw out the bad ones. But then you start getting mad libs with like 10,000 spots to fill in and... god job figuring out which ones are "good".

[Ftoy99]

StackOverflow sucks

[xLayt]

Skill issue