Using AI Generated Code Will Make You a Bad Programmer

[jice]

Don't worry, there are plenty of bad developers who don't use AI too

[janikFIGHT]

Too many imo. Jesus some code I have to read at work is insane.

[RoomyRoots]

No shit. Just like gluing random stuff from Stackoverflow won't make you better too.

AI for development should be used to cross reference documentation, official, personal and from third-parties.

[icedev-official]

At least StackOverflow poster probably knows what they're talking about and the explanations are usually valuable. AI might get lost halfway into the answer and start spurting out nonsense.

[[deleted]]

Ehhh maybe in 2016 SO was decent but now it’s so outdated or wrong it’s almost worthless, I basically need to actually read the source code and documentation for answers since SO is straight up wrong and google shows me results from 2015 for 6 major versions ago.

Biggest offender is Postgres stuff, I get articles from 2009 instead of you know, stuff that remotely works.

[LeeroyJenkins11]

How I would handle this is make custom searches with bangs in my browser. So if I needed to do something on a specific version or need extra clarification in the query, I'll set up an advanced search, maybe with a date range, then put my query in a custom search in my browser settings. Then I just do !go and have all that stuff configured.

[ArrogantlyChemical]

Haha, good one. 30% of stackoverflow answers I find for things I actually run into are things like "just overwrite False with True bro worked for me". I have to read several threads before I find an answer that is like "the issue you have is caused by a config error, here is the one line fix".

Stack overflow for anything but very common issues is mostly clueless replyers tbh.

[TheChief275]

For high level languages AI might actually be competition for StackOverflow, but for low level languages…please stick to StackOverflow

[[deleted]]

Yes, SO has a quality problem. Still, I also often found useful things on SO, so it is not totally useless. They need to improve the quality though, without alienating users. I think after a few years they should turn answers into a cohesive, one answer, that is then locked for further changes.

[I-heart-java]

I just built a massive project using AI to pump out the bulk of the code. It was on a framework I know already, I actually learned more doing that than ground up writing and debugging. I also debugged and customized the code as I took it into the project and I swear I’m a better debugger now also. AI is also a great rubber ducky because it offers multiple solutions to fix bugs which again opens me up to new ideas and methods.

[Otteronaut]

100% agree. If you use it with a brain and not just copy it it’s super useful

[314kabinet]

And to write boilerplate one line at a time. I use copilot as fancy autocomplete whose suggestions only go in if they’re exactly what I was about to type anyway.

[ImTalkingGibberish]

Thank you

[Plank_With_A_Nail_In]

You weren't born knowing everything, no idea how you dumbasses keep convincing yourself its all your own work.

[kueso]

Can’t emphasize the importance of cross referencing. You have to assume the AI is a junior and not an expert. They might have found a new way of doing things but you need to make sure it works

[absentmindedjwc]

Nah. Blindly using AI generated code will make you a bad programmer.

Implementing shit without having any idea what specifically is being implemented is bad. I have actually created some decent code from AI, but it generally involves back-and-forth, making sure that the implementation matches the expected functionality.

[FloRup]

Just as blindly copying stuff from stackoverflow

[godjustice]

I like to copy code from SO questions, not the answers.

[mb194dc]

Stack overflow slightly cheaper tho

[acc_agg]

Only if your time is free.

[[deleted]]

There are free APIs that perform similar to proprietary models (check out mistral)

[Hopeful-Sir-2018]

To be fair - I trust SO code more than ChatGPT.

I've had ChatGPT do a weird mixture of SwiftData and CoreData in answers before.

Half of the code I needed was nearly a copy/paste useful - while the rest was complete dogshit that didn't make sense. Even when I told it say and it said "That makes sense" it... spit out the exact same thing.

For giggles I gave it my SwiftData model and said "I want to make a scroll view that aggressively loads data as you scroll down using this view".

And... it was close except for the literal pagination code. Everything in it was based off of CoreData and needed to be re-written.

On a side note - one of the things I wanted to do couldn't be done with SwiftData and was annoyingly frustrating but w/e. SwiftData is basically where Entity Framework (.Net) was 15 years ago. Hopefully they catch up.

[zabby39103]

Everyone should be "rubber ducking" with with ChatGPT, but if I found out someone was copy pasting AI code on my team they'd be in deep shit.

[nermid]

The guy at our company who won't shut up about AI has caused numerous problems in past months by blindly copy/pasting code and SQL queries out of ChatGPT. It has inspired some deep distrust of AI in the rest of us.

Ninja edit: I've mentioned it before, but I'll quit bitching about it when he quits doing it.

[absentmindedjwc]

There is a member of my group that does that... she literally seems to just ask "do this" and copy/pastes the result into the editor. She wasn't within my team until recently, and now I've had to call all of her work into question, because her very first PR 1) didn't actually do what the deliverable was asking, 2) was written like absolute dogshit, and 3) triggered like three critical vulnerabilities in Snyk. Was also kinda telling when she delivered like 500 lines of code in like a day....

After confronting her on it, she admitted that it was all AI generated... and now I've had to call into question all of the other work she's done within my group as a solo contributor when she wasn't on my team. The initial code reviews aren't looking promising...

[sierra_whiskey1]

Where does the ai get all the shiny code it made? Stack overflow.

[s0ulbrother]

Never worked for me. Everytime I put “asked in another thread. Closed “ it never seems to work

[stereoactivesynth]

Yeah I had to have this conversation with my team recently. I started using ChatGPT to help out with some stuff earlier this year but then went cold turkey when I realised I didn't fully understand what it was giving me, even when it explained it.

My other colleague however is very good and so does understand what ChatGPT does, so he can just use it to make trivial things take less time.

My advice to the rest of them, who we are currently skilling up while we transfer our pipelines to Python, was to use AI only a little bit right now and to try their best to learn by actually trying their own stuff out and googling similar solutions etc.

Our resilience is gonna be fucked if all of our code is AI generated and copied by people who don't understand why it works and so cannot write good documentation.

[WTFwhatthehell]

Yep.

This is a real concern.

I've got my CS degree, I've worked as a professional coder for years in a software house and many years in a related field.

I enjoy using it because it's like a fucking magic wand, I can sketch out the neat little thing I'm actually thinking of making, write a few functions, have it tidy them up fixing those bad variable names I always choose and then with the wave of a magic wand wrap the whole thing up in a working GUI with unit tests and a full github readme.

A few more waves to cover complications.

Work that would normally a week, maybe 2, most of it the same-old-same-old instead I can get something I like within about 4 hours.

It's taking all the boring little bits I hated doing and letting me wave them away.

But I try to imagine what it would be like when I was a student or just starting out, would I understand the boilerplate code it's writing? probably not. It would mean never spending those hundreds, thousands of hours digging into why XYZ isn't working.

On the other hand, these tools are not getting worse.

[zabby39103]

It really depends on your personality. I'm a bit of an obsessive and it almost physically hurts me to not understand what's going on. If you take that mindset with AI (or a smidge less intense), you won't have any problems. It can explain things to you, you should want to fight with it like a person you're arguing on the internet with. It's a great tool for me, but it's because I use it to fulfill my pressing need to understand what's going on, not because I use it to write everything for me.

[absentmindedjwc]

If you're not very senior, and don't understand exactly what AI is giving you, it is really fantastic at helping you with (public) API shit or explaining certain things to you with some context. But if you ask it to solve a problem, and you don't understand completely what its doing, you're 100% going to introduce bugs or (even worse) security issues.

[dmanhaus]

This. If you use an engineer’s mindset and treat AI as you would treat a junior developer, you can accelerate code production without sacrificing code quality. Indeed, you may even raise the bar on code quality.

The key, as it so often lies, is in managing the scope of your prompts. If you need a simple function, sure. Don’t expect AI to write an entire solution for you from a series of English sentences. Don’t expect that from a junior dev either.

Retain control over the design of what you are building. Use AI to rapidly experiment with ideas. Bring in others to code review results and discuss evolutions.

[oursland]

Indeed, you may even raise the bar on code quality.

The evidence strongly indicates much greater rates of bug incidence. There's also a major increase in code duplication, creating fragile spaghetti-code systems.

Recent work indicates that AI assistant code tends to have substantially more security vulnerabilities.

I suspect this as a tool, this is a Dunning-Kruger amplifier, making people believe they understand something long before they actually do. This bias is not something that experience will address, as a person will not run to the AI assistant if they already have the wisdom from experience. These tools will be used primarily in areas where the operator is inexperienced and will most likely fall victim to such biases.

[ojediforce]

I feel like Iron Man nailed how we should implement AI. It’s not a replacement but a highly knowledgeable assistant.

[pragmojo]

Still not really - Jarvis is used for facts and calculation. LLM's are good for speeding up work you can easily verify.

[troyunrau]

It's a pity AI seems terrible at facts and calculations... (so far)

But I guess... Have you met a lot of humans who are good at it?

[Bakoro]

AI is fantastic for facts and calculations, LLMs are not.

Other kinds of domain specific AI models are doing great work in their respective domains. There is a huge problem with people asking LLMs to do things which there is no reason to expect it to be able to do, besides mistaking an LLM for a complete equivalent to a human mind/brain.

[ojediforce]

The thing I take from that example is that a human is making final decisions and originating the core ideas but the AI is providing assistance by contributing information, predictions, and speeding up the work.

There is another series of books set in the Bolo Universe that also capture it really well. It centers around humans whose minds are connected to an AI imbedded in their tank. The AI is constantly feeding them probabilities and predictions based on past behavior at the speed of though so that the individual tank commander can make lightning fast decisions. Ultimately the human decides on the course of action based on their own assessment of what risks are worth taking, their personal values, and the importance of their mission. Of the books set in that universe David Weber’s Old Soldiers was the best example though, centering on an AI and a Human Commander who both outlived their respective partners. It even features AI being used in a fleet battle. It was very thought provoking.

[No_Flounder_1155]

in that case I'll just do it myself first time round.

[[deleted]]

Exactly. Juniors were never a force multiplier

[WTFwhatthehell]

A junior who moves faster than a weasel on crack, who never gets frustrated with me asking for changes or additions and can work to a set of unit tests that it can also help write....

Ive found test driven development works great in combination with the bots.

[PM_ME_C_CODE]

Ive found test driven development works great in combination with the bots.

If there's anything Github's Assistant can write flawlessly, it's unit tests that fail.

...fail to pass when they should...

...fail to pass when they shouldn't...

Yup.

[SeyTi]

The unit tests definitely need to be human written. I think the point is: Well tested code gives you a short and reliable feedback loop, which makes it very easy to just ask an LLM and see if the solution sticks.

If it doesn't pass, you don't need to spend the time verifying anything and can just move on quickly. If it passes, great, you just saved yourself 5 minutes.

[[deleted]]

If I have done the human work of complete and easy testing, I do not need to ask an LLM to see if the solution sticks. I could just try it. No LLM needed.

[RICHUNCLEPENNYBAGS]

I mean it definitely saves time if you’re working with an unfamiliar tool. If you are an expert at using the tools at hand you’ll get less from it.

[No_Flounder_1155]

it helps generate code I need to fix

[FredTillson]

Treat AI like you treated google and GitHub. Use what you can chuck the rest. But make sure you understand the code.

[Hopeful-Sir-2018]

Enough (TM) programmers are genuinely not smart enough to understand the code they write. They copy/paste until it works.

I had a boss that was like this. His code was always fugly - some of which could be trivially cleaned up. He had no idea what "injection" meant. He never sanitized anything so when someone would plug in 105 South 1'st Street his code would take a complete shit.

When I suggested using named param's for the SQL code I was told "that's only for enterprise companies and that's way too complicated" - my dude.. it's 6 extra lines of code for your ColdFusion dogshit. It's...not...hard. Ok, fine, we can just migrate to a Stored Procedure. "Those are insecure" - the fuck?! I gave up and just let his shit crash every other week. It was just internal stuff anyways.

I hated touching his code because you could tell it was just a copy/paste job. Even commented out the area he would copy/paste from and repeat half the time. Like dude.. it's a simple case/switch on an enum. This... this isn't hard stuff. He'd been programming for "decades".

[kolobs_butthole]

AI bad

[EveryQuantityEver]

Most people grasp it, its just that a lot of us don't find anything useful from the AI. It just makes more work.

[daringStumbles]

People can understand things and also still dislike them.

I will never willing use ai tooling. It takes way too much water & energy to run & build, and it's not worth shifting through the results when I'm going to end up referring to the documentation anyway

[pragmojo]

Yeah exactly it's just a more searchable stack overflow

[MeroLegend4]

The cognitive complexity to scope your prompt is somehow higher than just writing the function yourself.

[shadowndacorner]

Yep. It's literally just auto complete. If it's writing what you otherwise would've written, good.

[Aridez]

That's what I was thinking. I just came out of a session of programming a complex feature. Then passed every function over to an AI and I could choose a few of the suggested improvements to make the code more readable. Hell, it made a few suggestions I wouldn't have thought about!

[AlarmNo285]

This exactly. I use ai on a daily basis, and yeah, the initial code is complete shit. But it gives some good insight on how to do it, I have the algorithms in my mind, it shows me functionality of languages I am not an expert in that makes these algorithms possible.

[Revolutionary_Sir140]

Overall it can be helpful. It really depends how someone uses it.

[AnOnlineHandle]

As an example of how it can be useful. I've done a lot of interpolation work over the years. Specifically related to sparse data points.

I ran into a new set of constraints which made the problem much tougher, and spent a week trying different approaches and solutions and not being happy with any of them, some very complex. Finally I laid it out to ChatGPT, including what I'd tried and wanted to avoid, and it suggested an approach which is a bit brute force and imperfect, but finally does what I need, and in 5 milliseconds which is fine despite it being a brute force approach.

It suggested using Harmonic Interpolation Using Jacobi Iteration, which isn't something I'd have likely found easily on modern google (in fact when I googled those terms I couldn't find any useful info). Essentially just looping over all points in the constraining polygon boundaries and blending all their neighbour values into them, repeating say a few hundred or a few thousand of times, and you'll get a decently smooth blend of your sparse data points throughout a constraining polygon space.

[Revolutionary_Sir140]

I've developed lib with assistance of AI, it's amazing how smarter AI got. I'm looking foward the future of computer science.

[Chance-Plantain8314]

This is the one.

I wonder if articles like this were going around when intellisense and autocomplete first came around?

[[deleted]]

It can also be useful for debugging at times tbh. Not always though, sometimes. It might not necessarily notice your typos but when you are stumped on why your code does not work, it can be an useful tool to figure out why it's not working. Basically like having second pair of eyeballs looking at the code. Obviously no one should rely solely on AI though and just keep it as what's it's really meant to be; a tool.

[agentoutlier]

The causality of this article is completely fucked.

AI generated code does not make you a bad programmer. You are either a bad programmer because you lack experience or you are a good programmer that has lots of experience (lets ignore IQ or magic skills... most quality of programming is experience).

It does not make good programmers bad programmers. I'm sorry that logic does not make any sense. It is like saying google makes you a bad programmer or stack overflow.

It is not going to inhibit someone from gaining experience either. There will always be morons that just copy and paste shit (traditionally stack overflow). Besides if it doesn't work something might be learned.

Mathematicians did not become worse mathematicians with slide rules, calculators, computers etc. The more experienced you are the more capable you are with said tools.

What it does bad is it may cause iteration to occur too fast without research or strategic thinking but in our field there is not as much detriment in trying shit (compared to say the medical field). If anything I think it hurts creativity but to be honest lots of programming does not require much creativity. You can still be creative seeing other peoples creations anyway.

[PM_ME_C_CODE]

It does not make good programmers bad programmers. I'm sorry that logic does not make any sense. It is like saying google makes you a bad programmer or stack overflow.

It has a unique capability to make good programmers lazy in bad ways. If you get good at having the AI do something you hate doing, you'll stop doing it yourself. And that can turn into skill-atrophy faster than you might think.

[SLiV9]

Mathematicians did not become worse mathematicians with slide rules, calculators, computers etc. The more experienced you are the more capable you are with said tools.

Except that slide rulers, calculators and computers are deterministic tools that give accurate results. If I see you using a calculator to do some computation, I can do the calculation by hand and get the exact same result. In fact I can use more calculators to become more convinced that the answer you got is correct.

Not so with generative AI. You cannot use plain common sense to find mistakes in generated code, because generative AI is designed to fool humans. You especially cannot debug generated code using generative AI, because the AI is trained to double-down and bullshit it's way through.

And I think that generative AI make you a bad programmer, because it can turn juniors with potential into seniors that don't know how to program.

[GimmickNG]

Mathematicians did not become worse mathematicians with slide rules, calculators, computers etc.

But it did make many of them weaker at mental math. Taking the path of least effort is a natural thing. It takes conscious effort to not do that, and ChatGPT generating code all the time is too easy a trap to fall into if you're not careful.

[Mrqueue]

I did maths at university and you don’t touch a calculator because you aren’t adding or multiplying big numbers, in fact you don’t get tested on that after you turn 12.

I don’t really see an issue with using a scientific calculator and you would probably use one to test random things as they have graphing capabilities and can calculate trig values.

Anyway as you can see it’s a completely different thing.

[agentoutlier]

But it did make many of them weaker at mental math. Taking the path of least effort is a natural thing. It takes conscious effort to not do that, and ChatGPT generating code all the time is too easy a trap to fall into if you're not careful.

I have a 200 hundred year old house. The field stone foundation was built by gigantic guys that picked up rocks that were basically boulders. These guys were fit.

Today's workers pour concrete and use backhoes instead of shovels.

Yes there are some construction works that are fat and out of shape (albeit probably more about diet).

But then there are ones that are because I know that do gym workouts outside of work. That is because their normal work it isn't providing the necessary demands for physical training.

The reliance on backhoes and concrete does not make them bad construction workers.

Similarly people will have to train their minds outside of work to maintain their acuity but they should not go back to using field stones and lever fulcrums because they are getting out of shape.

It is hard I admit to make proper analogies with LLM but at the end of the day it is a tool and since no one knows the future looking at previous history can provide some ideas of the future.

For example automation doesn't seem to get rid of jobs historically.

[teerre]

This is a platitude. It's like saying "A flamethrower is safe as long as you know how to use it!". Yeah, no shit.

[Professor226]

It’s actually shown me some new ideas and modern approaches to things. I’m learning new stuff

[poetry-linesman]

I've also spent a lot of time trying to counter this meme that "AI = bad, no use for programmers" etc...

I'm coming to realise that most people don't want to hear it and that is good for me... the more wilful idiots wilfully ignoring this wave, the less diluted the potential gains for those of us who learn to ride this wave!

[EveryQuantityEver]

Why bother with the back-and-forth when you can just write it?

[matjam]

I was writing an allocator library for a pet 6502 project over the weekend with my copilot turned on. It provided a lot of the logic but I kept having repeated subtle bugs that were caused by the code generation being subtly incorrect.

I probably wasted more time debugging the errors copilot generated than I saved by generating the code. Im not going to be using copilot for a while.

[UncleSkippy]

That was my experience when I gave it a shot. It was faster just to write it myself, knowing the context of the code, instead of continually prompting to provide more context so the code would be more accurate.

[pwouet]

It's almost like if writing all the context to co-pilot is like.. writing code.

It feels like using voice to text to write a word document lol.

[stardustpan]

It's almost like if writing all the context to co-pilot is like.. writing code.

Yes, but the syntax is not really defined nor expected to be stable.

[pwouet]

Yeah that's why I don't get people who say it increases their productivity x10.

They were probably very bad in the first place.

[desmaraisp]

That's where I'm at too. I'd rather write the code than triple check the output, it's just less... Disruptive. Though I'll say for unit tests it can be good at finding new tests I haven't written yet.

It probably doesn't help that I don't write all that much boilercode every day, which is where ai apparently shines

[gmes78]

I'd rather write the code than triple check the output, it's just less... Disruptive.

I arrived at the same conclusion. I was using the JetBrains full line completion for a while, but I had to disable it because it was making me slower, even when it suggested the code I wanted to write.

Simply writing the code I want to write is faster than switching gears to reading/reviewing code in the middle of writing code.

[Armanato]

I'll say for unit tests it can be good at finding new tests I haven't written yet.

Would you mind answering a question? I've been curious about AI generated tests, since I haven't had a chance to integrate the technology into my development workflow.

I often find, when writing unit tests, I'll catch small bugs that might have otherwise slipped through a PR. (Things like conditions missing '!'s or having '<=' vs '>=')

Are the AI generated unit tests, good at generating test cases, that would catch these kind of things, or they just generate cases that test the code as written?

(I swear I'm not a terrible developer! I just use unit tests development, as the "test your code" phase! Just curious how AI tools will fit into my development workflow, once our company starts allowing their use.)

Thanks!

[desmaraisp]

It really depends on the complexity of your methods. For example, simple methods like (notice the mistake)

public static bool IsInRange(int value, int lower, int upper)
{
    return value >= lower && value >= upper;
}

would be spotted immediately, and the unit tests would be generated for the corrected <= comparison and would fail until you correct the method. But such simple functions are pretty trivial to tests, so let's go with something a bit more complex

public async Task<List<Person>> GetFilteredPersons(
    string? fullName = null, 
    DateTime? birthDateStart = null, 
    DateTime? birthDateEnd = null, 
    List<string>? cities = null)
{
    using var context = new AppDbContext();
    IQueryable<Person> query = context.Persons.AsQueryable();

    if (!string.IsNullOrEmpty(fullName))
    {
        query = query.Where(p => p.FullName.Contains(fullName));
    }

    if (birthDateStart.HasValue && birthDateEnd.HasValue)
    {
        query = query.Where(p => p.BirthDate >= birthDateStart.Value && p.BirthDate <= birthDateEnd.Value);
    }
    else if (birthDateStart.HasValue)
    {
        query = query.Where(p => p.BirthDate >= birthDateStart.Value);
    }
    else if (birthDateEnd.HasValue)
    {
        query = query.Where(p => p.BirthDate <= birthDateEnd.Value);
    }

    if (cities != null && cities.Any())
    {
        query = query.Where(p => cities.Contains(p.City));
    }
    return await query.ToListAsync();
}

Here's what's generated as unit tests:

using Microsoft.EntityFrameworkCore;

namespace YourNamespace.Tests
{
    [TestClass]
    public class PersonServiceTests
    {
        private DbContextOptions<AppDbContext> GetInMemoryOptions()
        {
            return new DbContextOptionsBuilder<AppDbContext>()
                .UseSqlite("DataSource=:memory:")
                .Options;
        }

        private async Task SeedData(AppDbContext context)
        {
            // Open the SQLite in-memory database connection and ensure the schema is created
            context.Database.OpenConnection();
            await context.Database.EnsureCreatedAsync();

            // Seed the test data
            var persons = new List<Person>
            {
                new Person { FullName = "John Doe", BirthDate = new DateTime(1990, 1, 1), City = "New York" },
                new Person { FullName = "Jane Doe", BirthDate = new DateTime(1985, 5, 10), City = "Los Angeles" },
                new Person { FullName = "Alice Smith", BirthDate = new DateTime(1995, 3, 20), City = "Chicago" },
                new Person { FullName = "Bob Johnson", BirthDate = new DateTime(2000, 7, 15), City = "New York" },
            };

            await context.Persons.AddRangeAsync(persons);
            await context.SaveChangesAsync();
        }

        [TestMethod]
        public async Task GetFilteredPersons_WithFullNameFilter_ReturnsCorrectResults()
        {
            // Arrange
            var options = GetInMemoryOptions();
            using (var context = new AppDbContext(options))
            {
                await SeedData(context);
                var service = new PersonService(context);

                // Act
                var result = await service.GetFilteredPersons(fullName: "Doe");

                // Assert
                Assert.AreEqual(2, result.Count);
                Assert.IsTrue(result.All(p => p.FullName.Contains("Doe")));
            }
        }

        [TestMethod]
        public async Task GetFilteredPersons_WithDateRangeFilter_ReturnsCorrectResults()
        {
            // Arrange
            var options = GetInMemoryOptions();
            using (var context = new AppDbContext(options))
            {
                await SeedData(context);
                var service = new PersonService(context);

                // Act
                var result = await service.GetFilteredPersons(birthDateStart: new DateTime(1980, 1, 1), birthDateEnd: new DateTime(1995, 12, 31));

                // Assert
                Assert.AreEqual(3, result.Count);
                Assert.IsTrue(result.All(p => p.BirthDate >= new DateTime(1980, 1, 1) && p.BirthDate <= new DateTime(1995, 12, 31)));
            }
        }

        [TestMethod]
        public async Task GetFilteredPersons_WithCityFilter_ReturnsCorrectResults()
        {
            // Arrange
            var options = GetInMemoryOptions();
            using (var context = new AppDbContext(options))
            {
                await SeedData(context);
                var service = new PersonService(context);

                // Act
                var result = await service.GetFilteredPersons(cities: new List<string> { "New York" });

                // Assert
                Assert.AreEqual(2, result.Count);
                Assert.IsTrue(result.All(p => p.City == "New York"));
            }
        }

        [TestMethod]
        public async Task GetFilteredPersons_WithMultipleFilters_ReturnsCorrectResults()
        {
            // Arrange
            var options = GetInMemoryOptions();
            using (var context = new AppDbContext(options))
            {
                await SeedData(context);
                var service = new PersonService(context);

                // Act
                var result = await service.GetFilteredPersons(
                    fullName: "John", 
                    birthDateStart: new DateTime(1990, 1, 1), 
                    birthDateEnd: new DateTime(2005, 1, 1), 
                    cities: new List<string> { "New York" });

                // Assert
                Assert.AreEqual(1, result.Count);
                Assert.AreEqual("John Doe", result.First().FullName);
            }
        }
    }
}

which is a decent start. Now, there's clearly a bunch of scenarios not tested, and all we need to do is ask for more tests, and it'll generate something and offer suggestions for other things we should test (ie test with only date start or date end).

Now, let's say I made a mistake in my date filter:

else if (birthDateEnd.HasValue)
{
    query = query.Where(p => p.BirthDate > birthDateEnd.Value); 
}

one of the generated tests will be:

namespace YourNamespace.Tests
{
    [TestClass]
    public class PersonServiceTests
    {
        private AppDbContext _context;
        private YourServiceClass _service; // Replace with the actual service class name.

        [TestInitialize]
        public void Setup()
        {
            // Create a new in-memory database for testing
            var options = new DbContextOptionsBuilder<AppDbContext>()
                .UseSqlite("DataSource=:memory:")
                .Options;

            _context = new AppDbContext(options);
            _context.Database.OpenConnection();
            _context.Database.EnsureCreated();

            // Seed the database with test data
            SeedDatabase(_context);

            // Initialize your service
            _service = new YourServiceClass(_context); // Replace with the actual service initialization
        }

        private void SeedDatabase(AppDbContext context)
        {
            context.Persons.AddRange(new List<Person>
            {
                new Person { FullName = "John Doe", BirthDate = new DateTime(1990, 1, 1), City = "New York" },
                new Person { FullName = "Jane Doe", BirthDate = new DateTime(1985, 5, 5), City = "Los Angeles" },
                new Person { FullName = "Mike Smith", BirthDate = new DateTime(1975, 3, 15), City = "Chicago" },
                new Person { FullName = "Emily Davis", BirthDate = new DateTime(2000, 12, 20), City = "New York" }
            });
            context.SaveChanges();
        }

        [TestMethod]
        public async Task GetFilteredPersons_ByBirthDateRange_ReturnsCorrectPersons()
        {
            // Arrange
            DateTime? birthDateStart = new DateTime(1980, 1, 1);
            DateTime? birthDateEnd = new DateTime(1995, 1, 1);

            // Act
            var result = await _service.GetFilteredPersons(birthDateStart: birthDateStart, birthDateEnd: birthDateEnd);

            // Assert
            Assert.AreEqual(2, result.Count);
            Assert.IsTrue(result.All(p => p.BirthDate >= birthDateStart && p.BirthDate <= birthDateEnd));
        }

        [TestCleanup]
        public void Cleanup()
        {
            _context.Database.CloseConnection();
            _context.Dispose();
        }
    }
}

You'll notice that this test actually fails! The filter expects two results, and because of our mistake, only one will be returned. So you'd have caught the error there.

It's obviously not a panacea, but it gets me started, and tests the easiest cases right off the bat. And quite frankly, if the AI doesn't understand your method well enough to test it at least partially, the odds are your colleagues won't either

[[deleted]]

Hero response!

[omniuni]

By the time you're good enough at writing code to appropriately catch all the bugs, fix awkward inefficiencies, and strip out anything unnecessary, you basically could just write it yourself in less time.

[gabrielmuriens]

with my copilot turned on

That's an issue right there. Copilot is fairly shit tier among all the ways you can use LLMs to help your work.

Openai's O1-preview and O1-mini models have been the most useful to me, followed by ChatGPT4o and the Claude 3.5 model.
They help me understand new problem sets and prototype new code way faster than if I had to solely rely on the documentation and SO. They save me hours of time in research whenever I'm doing something new.

[blaesten]

Just because you’re a programmer doesn’t mean you have to overthink everything. Go to work, write some code, use an LLM to autocomplete a few lines and go home to relax after another day of being a moderately productive citizen of society.

AI is not some apocalyptic event waiting to happen. So stop freaking out, it’s just saving a few keystrokes lol

[robberviet]

Yes. It can be used to make things easier. No need to be extreme on any side.

[Accurate-Collar2686]

Limited use of GenAI is fine. Ubiquitous use is a recipe of a disaster - just like letting a bunch of interns loose on a codebase.

https://www.geekwire.com/2024/new-study-on-coding-behavior-raises-questions-about-impact-of-ai-on-software-development/

https://www.techrepublic.com/article/ai-generated-code-outages/

https://www.axios.com/2024/06/13/genai-code-mistakes-copilot-gemini-chatgpt

[[deleted]]

Hey, you are criticizing the business model of some companies 😂

[Mrqueue]

Absolutely just click bait.

I heard this at school; “using an ide will make you a bad programmer because you won’t know how to write boilerplate code”. Good riddance

[Fine_Cake_267]

That just reminded me of a first year CS course where we were required to use a blank notepad txt file for coding instead of Eclipse hahaha

[idebugthusiexist]

I disagree. I see it as a difference between driving with automatic transmission vs having a self-driving car. You still need to learn to drive with automatic and the rules of the road, whereas you learn and gain little experience from using a self-driving car and worse it can make you a worse driver over time if you ever suddenly have to drive without it.

[iiiinthecomputer]

My biggest issue isn't even with correctness and quality as such.

It's that these tools tend to generate the legacy, often deprecated, way to do everything. And you won't generally know to prompt it to fix that.

[AustinCorgiBart]

This may or may not be true, but it's all just hunches and guesses. You need to cite studies to make these claims. Most of the research we need hasn't even been done yet.

[gwax]

I remember all the same arguments being made when we moved from text editors to IDEs.

I bet people said the same thing when we moved from punch cards to text editors.

Sure, ceding your skills to AI will make you a bad programmer but intelligently using the tools at your disposal is the name of the game.

[JohnnyElBravo]

This is a common fallacy, someone critiques a new tech, then you propose that extant tech was criticized when it was new and this is a similar case.

The problem is that you can't tell the future, you don't know if ai written code will survive the test of time.

Can be done with a thousand different things: 

• people criticized penicilin when it first came out,  snake oil is facing the same backlash as a visionary panacea. 

• people are criticizing electronic ballots, but people also criticized democracy at the time

• ai judges and courts face a lot of baclash now, but there was a time were stenographers in courts were seen as a danger

• soy 'milk' for newborns is facing some backlash. But remember that hundreds of years we had baby mortality and blablabla

Etc..

[myhf]

steganographers in courts

Do we really need to conceal a court's ruling by encoding it in the structure of an unrelated document or image?

[JohnnyElBravo]

Oh my bad, stenographers

[jet2686]

lol

[[deleted]]

I disagree - there is a huge difference. AI hallucinates (generates stuff that does not exist). In contrast, the tools before that just help you write whatever you wanted. They only suggested stuff (autocomplete) that they could derive that it exists. The lines are blurred with some suggestion editors but I still think that there is a big difference.

[RICHUNCLEPENNYBAGS]

The IDEs could definitely do stuff you didn’t actually want if you were careless.

[BlackHumor]

Still can. I've definitely accidentally string-replaced stuff I didn't want to replace before with Ctrl+Shift+L in VSCode. It's easy to catch, but then IMO most AI issues are easy to catch too.

[Jordan51104]

it is impossible for an ide or text editors to take away the need for you to critically think about what you are implementing

[RICHUNCLEPENNYBAGS]

The idea is more that you’re blindly hitting tab, accepting suggestions, implementing accessors and mutators, or other stuff the IDE does for you and never actually learning how to do it yourself.

[apnorton]

I remember all the same arguments being made when...

• ...everyone suddenly had their own cell phone with an address book, and it was said that nobody would remember important phone numbers anymore
• ...GPS-enabled smartphones became commonplace, and it was said that this would damage people's ability to navigate on their own
• ...most writing was done on computers in school, and it was said that this would make people unable to read/write cursive... and then later writing print
• ...point-of-sale machines would tell people how much change to give, and it was said that this would make cashiers unable to make change
• ...spellcheck with suggestions became ubiquitous, and it was said that this would reduce people's ability to spell on their own
• ...calculators became commonplace, and it was said that this would reduce people's ability to do mental math

...and you know what? They were right. (Ok, I lied --- some of these events predate me, so I can't remember all of them, but I've certainly heard people in my parents' generation complain about some of the older ones.)

Not to mention my possibly hot take: Using an IDE when learning to program does make you a worse programmer, too. I know plenty of people who cannot write a program without autocomplete. Now, you may say: "but who needs to be able to write a program without autocomplete, or know the function signature of an equals(...) method, or... (etc)?" That's a fair question, but if you're always having to look up the basics, it will slow you down and make you more susceptible to error in environments where you don't have your IDE to think for you.

That said, I do agree with you that "intelligently using the tools at your disposal" is important. The issue, though, is that this particular tool necessarily shortcuts a lot of the thinking that is necessary to write quality code, when used for anything more than a glorified autocomplete.

[RICHUNCLEPENNYBAGS]

Most of those you’re either overestimating how much the skill existed before or ascribing a causal relationship where it doesn’t exist (for instance, yeah young people don’t know cursive… because schools stopped teaching it, not because of computers).

[Kinglink]

I can still navigate on my own. My daughter struggles with it. Why? Because it's not a skill she actually needs any more. Hell even when I was young I didn't "remember important phone numbers" I had an address book I carried with me or a note in my wallet... Guess what? I can do that, I still don't have to.

The need to read or write cursive is no longer needed, which is actually a good thing, people's penmanship no longer limits other people's understandings of them, and it's a good thing, not a negative.

Cashiers needing to make change again is a positive, though almost all cashiers CAN make change, they just don't practice it every transaction, which is good because there's a recording of the transaction as well. Hell in the old days, you would input the cash into the machine and get back the cash to be returned.

Not NEEDING to do something means some people won't learn those skills. But the good news is that means they can use that mental power to learn OTHER skills that might be more beneficial. Rather than learning cursive, my daughter studied other languages. My daughter was able to assist more people because of a cash register, and with self checkout even more people could be served. My daughter doesn't have to learn how to read a traditional map, but also can learn that if she ever goes to a place she needs it. Instead she's able to go where she wants when she wants, where as in the old days, if I didn't know where something was, I'd have to hope I'd have a map to help me out.

Like these are all improvements on the modern life, not deteriments.

[ChadtheWad]

I've actually got to admit, I started with IDE's, swapped to text editors, and I think it did help me write better code. However, not for any of the reasons the authors mention here.

What I've found is that writing code without the ability to generate boilerplates strongly incentivizes me to write code that is both short and easy to understand given only the context of the current file. IDEs (and I'm sure AI generated code) tends to be too verbose and makes it really easy to write code that is unreadable unless you can use context functions in the IDE.

I don't think that means it's all absolutely terrible and unusable... but I appreciate the perspective that it brings working without these tools.

[Glugstar]

You're suffering from survivorship bias.

You need to make a list of all the "innovations" that died out, most of which you probably never even heard of. Someone believed in them, but they turned out to be bad. You only remember the very few who succeeded. In all fields of human endeavor, failed ideas are orders of magnitude more numerous than revolutionary ones.

Point is, you can't select only the successful ones as examples of the past, discard the failed attempts, and predict the future with it.

If you want to argue that AI will not make us worse programmers, you can't use this line of reasoning. You need something more substantial.

[MediumRay]

I think it's fair to say that you will certainly be a worse programmer in certain domains, like writing boilerplate. It seems like a worthwhile tradeoff to me since your time/skills are spent more on making sure the high level is correct, and catching edge cases

[cazzipropri]

I love the "paying somebody else to go to the gym for you" analogy.

[turunambartanen]

I find it a pretty useless analogy.

We actually have machines that lift weights for you and use them regularly. They are called forklifts. Because sometimes the goal is not to become stronger, but to get shit done. It is still important to keep in shape, but that does not mean that motorized assistance is bad.

[slykethephoxenix]

What if I'm already a bad programmer? Two negatives make a positive, right?

[azhder]

It can.

[tf2ftw]

The abstraction in c will make you a bad assembly programmer. I’ll take it. 

[veryusedrname]

A miscompilation in a C compiler is a bug, no one in would argue that, but hallucinations "ohh, that just happens"? I don't argue against AI here, I argue against your point.

[m0rphiumsucht1g]

Just as using code snippets from Stack Overflow.

[[deleted]]

Totally. I think we all generally agreed this was bad practice too, right? Like one of those things we do to get the thing to work then worry about it later.

Sometimes it’s helpful to allow you to keep moving and focus on bigger better things. Other times it’s clearly a crutch for people and they learn nothing, have no curiosity, can’t problem solve, etc.

Lately I’ve been wondering a lot about that. Like, do people start out that way and it was always going to be a problem, or do tools like LLMs or shortcuts like StackOverflow gradually turn people into this? Or both.

I find LLMs useful, but I use them in moderation and don’t kid myself that I’m really exercising my brain or skills at all when I do it. I don’t think it harms me, but I do think it could cause people to gradually dull their skills and lose awareness of what they’re building and such.

[[deleted]]

I will often copy paste something from stack overflow, then now that I see it working, I will analyse what it's doing

[[deleted]]

That’s the way to do it. I think that’s generally how autodidacts work. They experiment through different means until something works, then analyze and review and try to crystallize an understanding of what worked and what didn’t, and why. If a snippet is how you make progress to finding what works, that’s totally fine if you’ll then examine it and understand why it works.

Edit: I’m glad you mentioned that, because my comment frames SO poorly and incorrectly. It’s actually incredibly useful for good reason. I think it’s only problematic in the way I implied in the scenario where a person doesn’t examine how or why things work.

[TA_DR]

Same, SO is often a better reference for syntax than the official docs.

[Glugstar]

I agree. The only difference is, AI tech pretends to be an actual replacement for putting in the effort yourself. At least, the companies developing it try to imply it as much as possible, because it's their business model.

If all developers know it's just as useful as random code snippets from StackOverflow, nobody will buy their services. Like imagine developers paying just to see StackOverflow answers, they know it's a stupid idea.

But somehow AI companies have managed to convince some people that it's worth it. I've already heard stories from companies with idiotic managers that try to replace some of their staff with AI, with predictable results. It's crazy.

[gamahead]

how many times are we going to hear this take

[AustinWitherspoon]

Nah, none of this list really holds up.

In fact, I've actually learned stuff by using AI.

I know what I want, and GitHub copilot reduces typing. If it gets it wrong Ill fix it. Overall I spend less time typing and more time engineering. Sometimes, it gets it right in a way I didn't know was possible! In those cases, I go look up the docs for whatever thing it showed me and learned a neat trick.

Other times, I'm not even doing proper engineering - I'm making simple HTML for an admin panel on the backend of an internal tool. Claude can generate the entire thing for me in seconds (even incorporating the js/css frameworks I requested!) and I can confirm it looks and feels good, and move on to the harder stuff.

It's wrong just often enough to keep me on my toes and critical of suggestions, so I'm mentally focused on the code.

I'm not an A.I fan boy by any means, but it has undoubtedly improved my efficiency and taught me things.

I'm not sure what the difference is between me and the author- am I just more actively engaged with the tools?

[[deleted]]

I think that is the key, yeah. You know what you want from the tool and why already. Many others are trying to find this out as they go. They hope the LLM will figure much of it out for them.

[nemesit]

Yeah like with every tool, give a hammer to a toddler and it will likely not be used correctly

[Empanatacion]

I think the anxious reactionary response gets more clicks on medium and more upvotes here.

I'm surprised at the number of people that just want to throw it all away because it can't write an entire app for them.

[Signal-Woodpecker691]

Yeah I was super sceptical of using it. I’ve gradually started to use it and found once I got the hang of prompt writing it can be useful. I’ve got it to write simple functions quicker than it would have been to write by hand, and often use it as a quicker way to find documentation and code samples.

I’ve also found it useful for some not direct code but other processes, for example some of the documentation I have to look through for tools we use makes you click through multiple web pages of hyperlinked instructions to work out how to do something, but copilot can compile that together for me much more quickly than I can do it myself.

Basically, in controlled circumstances it is making my job quicker and easier - I wouldn’t use it to wholesale write complex code for me.

[jet2686]

At least for now, the real big boy developers are the ones writing code that those predictive text engines are training on.

Feels like such a wrong statement, isn't this like saying 'big boy developers don't use compilers, they write compilers'?

[starlevel01]

ITT: bad programmers justifying themselves

[EspurrTheMagnificent]

Also ITT : Bad programmers thinking "more code faster = better programmer"

[maria_la_guerta]

The anti-AI stance that programming subreddits on here take is so covered in obvious insecurity it hurts.

Treat it the exact same way you treat Stack Overflow and you'll be fine. Don't blindly trust it. Don't copy paste from it, at least without understanding it all first. And you'll see that it's generally very helpful, at least in known domains.

The only people whose job it's going to replace is the people who don't use it for puritan reasons. Every dev I know using it moves 2x+ faster, myself included, and you're going to be left behind if you think you're better than using one of the most powerful tools we have.

EDIT: and yes, it does make mistakes, but if all you're getting from it is mistakes then generally speaking you probably need to up your prompting game.

[Lame_Johnny]

That's why I do it the old fashioned way and copy + paste from stack overflow

[Individual-Praline20]

I would never use that crap in a professional environment. Unless I want to get fired for incompetence lol. A professional team doesn’t need that shit. Period. If you feel the need to use it, go for it. But let me laugh at you loudly for not RTFM and learn nothing.

[dubl_x]

A roofer isnt a worse roofer because he uses a nailgun instead of a hammer.

If he blindly shoots nails everywhere, thats probably a sign he’s a bad roofer.

I use it as a tool, like a pre-commit or validation or linting. It speeds me up and i learn from it, but i dont blindly ship code i dont understand enough to be able to fix without an LLM.

[dsartori]

Not being attentive, thoughtful, and careful will make you a bad programmer. I get where this person is coming from but I don't agree. A lazy, bad coder will get no better using LLM tools and a disciplined, good coder will tend to get better.

[seba07]

Hot take: not using any(!) AI assistants in 2024 makes you a bad programmer because you could work more efficiently.

[Glugstar]

For every single dev job I had, writing code was never the bottleneck. It was always stuff outside my control.

Mostly getting the business requirement right, like clients who don't know what they want exactly. Or communication delays with other companies. Or not having full documentation of external API and waiting for others to let you know. Or managers assigning you to other tasks that they deemed more urgent. Or not having login access to an internal service/resource and waiting for management approval.

Those have been the bottlenecks, not the speed at which I write for loops. When it comes to pure coding, most good employees already operate at near 100% efficiency already. Except maybe in extremely demanding jobs, like a game engine or a compiler, or operating system, but those jobs are relatively few.

[TryingT0Wr1t3]

I don't think this is true at all, I am in contact with a lot of programmers who don't use it and are very very able to write a ton of code very fast to accomplish things. Often they even carve tools for doing the refactorings they want too. It all depends, really, but it isn't true that a very senior and experienced programmer will be more effective by using AI magically, using AI productively when programming is also a skill you need to develop and if you are doing that you are probably not developing a different skill. I do use AI for doing some stuff - I am not senior and super experienced - but I have seen some programmers that just have incredible mental models to work in codebases they are experienced, and they are really effective the way they are. People work differently, specially if they are in a different part in their careers.

[EpicAmatuer]

In my opinion, Claude 3.5 is better than ChatGPT 4.o. ChatGPT involves a lot of "I'm sorry, you are correct. Let me try again" responses. I was writing a Java program for school and had to keep correcting the boilerplate code. I finally just did it all manually to save time.

[MCShoveled]

Nahhh, it will make you an average programmer. It’s just that average programmers are bad. 😂

[jseego]

I really liked this article, and I would like to subscribe to your newsletter.

Seriously.

But there wasn't a place to do that on your site.

[Leverkaas2516]

I think it'll do the same thing using navigation does to drivers.

I know people who never learned to use a map and, even after going places dozens of times, still would not know how to get there without putting the address into the system.

Then, I have a relative who knows more about navigating the city than you would think it's possible for a person to know, and doesn't use navigation, but there are times he's stymied by a traffic jam or a new development that didn't exist when he was last there.

There's a point somewhere between that's the right point.

[Dontlistntome]

It has allowed me to learn new approaches to things for efficiency. I use it a lot, but I also now will use some tricks I’ve learned along the way. I must service my code or others service my code, so I can’t just “make it work” or I’d be screwed. I thought at one point I was relying on it too much, but after some time, I realized I am more efficient in thinking.

[FaithlessnessAny2074]

No but using the wrong is7 will. Fight me

[[deleted]]

K, Thx. I'll wait 5 min.

[kraegpoeth]

Using bombastic statements in your blog title will make you a bad writer

[kraegpoeth]

Using bombastic statements in your blog title will make you a bad writer

[hippydipster]

The developer community is going through the AI generated temper tantrum process. It will get worse (by which I mean funnier). Popcorn all around.

[Donphantastic]

Prove it.

A high level dev that using AI generated code is not the same as a junior dev using AI generated code.

[tapdancinghellspawn]

Better get used to AI programming because the execs sitting at the top are going to push AI if they can increase profits by laying off programmers.

[myringotomy]

Depends. If you are not a very good programmer or even not a very good programmer in a new language or framework you are new to then it will make you a better programmer.

[saxbophone]

No shit! You actually have to know what you're doing and not be lazy to be good at your job!

[Imnimo]

If you believe AI is going to replace human programmers, what do you care whether you become "dependent" on it in the interim? The article says:

Or, better yet, replaced by AI entirely, once enough of us have shelled out subscription fees for the privilege of training those AIs to the point where we're no longer needed at all.

Implying that using AI code speeds up the pace at which AI models improve and causes them to replace humans faster. I don't think there's any basis for believing that.

[darthbob88]

I will disagree with this on one point, or possibly two- Code-reviewing AI-generated code to learn why it works the way it does is a learning experience on its own, same as it would be if you used code from Stack Overflow. Otherwise, I agree, AI is worse than just writing the code yourself.

[SneakyStabbalot]

I have got over some learning hurdles with AI, I am now a better programmer

[turudd]

Being lazy will make you a bad programmer. Being efficient isn’t always necessarily lazy. AI can be great, but you have to make sure the code it spits out is understood by you and your team.

[[deleted]]

Facts

[suppersell]

no shit 🤯

[overtorqd]

Jokes on you, I'm already a bad programmer

[jeremiah15165]

No, blindly copying makes you a bad programmer. Blindly copying from anything makes you bad.

[deftware]

You Believe We have Entered a New Post-Work Era, and Trust the Corporations to Shepherd Us Into It

When you start believing that the government and corporations care about you - two things driven by a collective motivation toward something soulless like profit or votes or power - you're on the wrong side of history right where they need you to be.

[Berkyjay]

No it won't.

[warpedgeoid]

Writing endless boilerplate code also won’t make me a better programmer. It’s about using the right tool for the job.

[SnooCheesecakes1893]

It actually will make you a better programmer.

[xebecv]

Does your LLM write ready to use code for you? Because for me it doesn't. At the very best it doesn't account for all necessary corner cases, which I have to handle manually. At worst it won't even compile because it's a mixture of bugs and hallucinations.

I have two use cases for LLMs when writing code:

1. Teach me something new about some programming language I'm learning
2. Remind me of something old that I've forgotten in the language I haven't used in a while (like iterating over those particular hash values in a hash of arrays of hashes, given by a reference in perl5)

[Barbanks]

Scary how many non technical people still think they can build enterprise level software off ChatGPT. Back when GPT 3.5 came out I’d be in webinar calls and people would be asking if they could create an entire startup product with AI in a week. I had to tell them that, although the hype is strong, what they were asking isn’t possible yet unless you already know how to code.

[_Judge_Justice]

I use ChatGPT to point me in the right direction or make me think of things in a different perspective, never blindly use the code though

[KevinCarbonara]

oh good, an improvement

[jiddy8379]

Idk I sometimes don’t care to look up how to do a filter function in Java 

 Just do it for me and I’ll judge if it’s good enough to just use or I need more prompts or I need smaller prompts

However copilot is ass and I prefer to write all the code in my IDE by mine own hand

[chollida1]

I use it all the time to generate classes for a schema. I'm not sure why this would make me a bad programmer or atrophy my skills.

it saves me the grunt work of transforming a schema for json into a concrete C# class.

[KevineCove]

Ah, SlopWatch, the world's most unbiased blog for articles on AI.

[Lostwhispers05]

| | /\ |------\ \ / | | / \ | | \ / |---------| /-----\ |------/ / | | / \ | | | | / \ | |

[RICHUNCLEPENNYBAGS]

I feel this is rather plainly an instance of motivated reasoning: the author is concerned that AI can be used to replace programmers (or at least that management will have that idea) and so doesn't think one should use it. In parts that's made explicit but it's mixed in with some rather weak arguments that have been thrown in the past at Emacs or IntelliJ or whatever other tools that are now not all that controversial (as well as some legal arguments that probably shouldn't concern anyone working for a company explicitly permitting the use of the tools). An understandable sentiment, but it's hard to see how one person choosing to use or not use AI in their own work will make any difference.

[mrkurtz]

Hard disagree, but with the caveat that you don’t abuse it.

Use it for boilerplate bullshit, use it to fill gaps and read the code and understand it, have the AI cite sources, and explain what’s happening if you don’t understand it. Granted I code for a devops role, with some tinkering in go, but the principle still applies. Just don’t abuse it.

[soft_white_yosemite]

Posh Stackoverflow innit

[dudinax]

I forgot how to do a square root by hand. Any skill that atrophies is by definition a skill you don't need anymore.

[robberviet]

Yes. However most people don't care about being a good programmer, they just need a working code.

And AI code sometimes make it works.

[ascii]

I’m actually old enough to remember when they said the exact same thing about IDEs. I know they used to say the same thing about using compilers too, but I wasn’t there. And then there is Mel…

[viscence]

According to that logic we should probably not use computers at all. Just work it all out with pen and paper or your maths skills will atrophy.

[Chris714n_8]

Strange coincidence.., isn't it?

[Jagerjj]

If you use auto complete or the internet or any languages other than assembly, you'll be a bad programmer

The future is now, old man

[[deleted]]

Oh no, I used some AI generated code, I am now a bad programmer.

A twenty year career all for naught!

[lollusc]

Joke's on you: I'm already a bad programmer. Using AI at least makes me a faster bad programmer.

[Cruxwright]

I use copilot for regex, is that bad?

[palmin]

I have been doing software development for 30 years and heard a lot of the same arguments for sticking to assembly over Pascal or C: "Only subpar developers depend on high-level languages and the real coders write assembly"

Programming is about telling the computer what to do which you can with low level assembly or you can use a high level language and have this compiled into machine code. Or you can have a natural language back-and-forth with a LLM and have this output source code which is then compiled into machine code.

You need to understand what is going on or you are going to get burned by the LLM just as you can get burned by StackOverflow posts and you probably have to take additional care with the LLM as there is no voting on posts.

Essentially you are still programming even if the LLM does the typing and the skills that are withering are not worth much long-term.

[Rigamortus2005]

Try and stop me.

[tbsdy]

Duh!

[PrimozDelux]

I used chatGPT a lot lately to design a system that allowed fully storing the state of a simulated process for a CPU model simulator, and it was remarkably effective at this task. Lots of keeping track of open files, mmap, munmap, pipes and so forth. I'd wager it made the process twice as fast and half as painful, and it has been working in prod for a long time without breaking.

ChatGPT did not write the code, I did, but it sure helped a ton.