Why CoPilot Is Making Programmers Worse

Summary

Ce script discute les implications de l'utilisation des outils pilotés par l'IA comme GitHub Copilot sur les compétences des programmeurs. Il souligne les inconvénients potentiels, tels que l'érosion des compétences de base, la dépendance aux solutions générées par l'IA, et la fausse perception d'expertise. Le texte met en garde contre la 'dépendance apprendue' et encourage à maintenir une compréhension profonde du code pour innover et résoudre les grands problèmes.

Takeaways

• 🤖 L'utilisation des outils pilotés par l'IA comme GitHub Copilot peut augmenter la productivité des programmeurs, mais cela peut également avoir des conséquences négatives sur la qualité et les compétences des programmeurs.
• 📚 La dépendance aux outils d'assistance à la programmation peut entraîner l'érosion des compétences de base en programmation, car les programmeurs peuvent oublier les détails importants des langages si ceux-ci ne sont pas régulièrement utilisés.
• 🧠 L'assistance par l'IA peut conduire les programmeurs à contourner les étapes clés du débogage et de la résolution de problèmes, ce qui peut affecter leur capacité à développer des compétences de pensée critique et de résolution de problèmes.
• 🔄 L'auto-génération de code peut entraîner une dépendance aux solutions générées par l'IA, sans vérifier la correction, l'efficacité et la maintenabilité du code.
• 🔄 Une étude a montré que le taux de modification du code a augmenté après l'introduction des LMM, passant de toutes les six mois à toutes les deux semaines en moyenne.
• 🚩 Le code généré automatiquement peut parfois ne pas être la solution optimale pour un problème spécifique, et la confiance excessive dans ces outils peut conduire à accepter du code inefficace, buggé ou non sécurisé.
• 👥 La dépendance aux outils d'assistance à la programmation peut mener à un manque de propriété et de responsabilité pour le code écrit, ce qui peut affecter la qualité globale du code et la productivité de l'équipe.
• 🔗 L'utilisation d'outils pilotés par l'IA peut créer une dépendance aux plateformes propriétaires, ce qui peut isoler les développeurs des communautés de programmation et des outils open source qui encouragent la collaboration et le partage des connaissances.
• 💡 La génération automatique de code peut donner aux développeurs une fausse perception d'expertise, les faisant croire qu'ils sont compétents alors qu'ils ne comprennent pas pleinement le code qu'ils écrivent.
• 🚀 Les développeurs doivent éviter la 'dépendance apprendue' et la 'fausse expertise' et continuer à développer leur propre capacité à résoudre des problèmes et à comprendre le code, plutôt que de compter entièrement sur les outils d'assistance.

Q & A

Quels sont les outils AI-driven mentionnés dans le script qui pourraient avoir un impact négatif sur les compétences des programmeurs?

Les outils mentionnés sont GitHub Co-pilot et les IDE avec des fonctionnalités d'auto-complétion avancées comme les LSP (Language Server Protocol).

Quel est le risque majeur souligné par le script en ce qui concerne la dépendance aux outils de programmation AI?

Le risque majeur est l'érosion progressive des compétences de base en programmation, comme l'oubli des détails importants des langages de programmation.

Pourquoi le script suggère-t-il que les développeurs peuvent perdre leurs compétences en utilisant des outils AI?

En utilisant des outils AI pour générer du code, les développeurs peuvent oublier les détails et les mécanismes fondamentaux du code, car ils ne sont pas obligés de les écrire eux-mêmes.

Quels sont les effets secondaires du script sur le développement de compétences de résolution de problèmes chez les programmeurs?

En acceptant des extraits de code générés automatiquement, les programmeurs peuvent ne pas développer pleinement les compétences de résolution de problèmes et de pensée critique nécessaires à la programmation.

Quels sont les arguments avancés dans le script contre l'utilisation excessive des fonctionnalités d'auto-complétion des LSP?

L'utilisation excessive peut conduire à une dépendance aux outils, réduire l'incitation à refactoriser ou à réviser le code, et limiter l'apprentissage des compétences de base.

Quel est l'impact du script sur la perception de l'expertise des développeurs?

Le script suggère que les développeurs peuvent avoir une fausse perception d'expertise, en croyant qu'ils sont compétents en raison de leur capacité à générer rapidement du code avec l'aide des outils AI, même s'ils ne comprennent pas pleinement le code.

Quels sont les dangers potentiels mentionnés par le script de la dépendance aux solutions générées par AI?

Les dangers potentiels incluent l'acceptation de code inefficace, buggé ou non sécurisé, et la réduction de l'incitation à refactoriser ou à réviser le code.

Quelle est la position du script sur l'idée de ne pas tout comprendre en programmation?

Le script suggère que les développeurs ne doivent pas se fier uniquement aux réponses des outils AI et qu'ils devraient avoir la capacité à comprendre et à résoudre les problèmes eux-mêmes pour éviter une dépendance détrimente.

Quels sont les avantages potentiels de l'utilisation des outils AI en programmation, selon le script?

Les avantages potentiels incluent l'amélioration de la productivité, la facilitation de la navigation et de la refactorisation du code, et l'assistance dans la résolution d'erreurs.

Quels sont les défis pour les développeurs en termes de compétences et d'apprentissage soulignés par le script?

Les défis incluent la maintenance des compétences de base, la capacité à résoudre des problèmes sans l'aide des outils AI, et à ne pas devenir dépendant de la 'l'aide apportée' pour chaque problème.

Outlines

00:00

🤔 Impact des outils IA sur les compétences de programmation

Le script discute de l'influence des outils pilotés par l'IA, comme GitHub Copilot, sur les compétences des programmeurs. Il est suggéré que ces outils, bien qu'ayant des avantages en termes de productivité, peuvent avoir des conséquences négatives sur la qualité et l'ensemble de compétences des programmeurs. L'auteur exprime une inquiétude que les développeurs qui dépendent de ces outils pourraient perdre leurs compétences de base en programmation, comme le montre l'exemple de l'oubli des détails de la syntaxe Rust après une période d'inactivité. Il souligne également l'importance de la résolution de problèmes et de la compréhension profonde du code pour le développement durable des compétences en programmation.

05:01

🔄 Dépendance au code auto-géré et manque de propriété

Le paragraphe aborde la dépendance aux solutions générées par l'IA, comme GitHub Copilot, qui peut conduire à une compréhension superficielle du code généré sans vérification de sa justesse, d'efficacité ou de maintenabilité. Il est mentionné un changement dans la fréquence de modification du code sur GitHub, passant de tous les six mois à toutes les deux semaines après l'arrivée des LM. Cela soulève des questions sur la qualité et la fiabilité du code généré. L'auteur exprime également son mécontentement avec la perte de sens de propriété et de responsabilité sur le code qu'il écrit, ce qui peut mener à un manque d'incitation à réviser ou à réorganiser le code.

10:03

🚫 Le danger de la dépendance aux outils propriétaires

Ce paragraphe traite de la dépendance aux plateformes propriétaires, comme GitHub, qui peuvent entraîner une isolation des développeurs des communautés de programmation plus larges et des outils open source. Il est question de la fausse compétence que les développeurs peuvent ressentir en utilisant des outils d'assistance à la codification, ce qui peut conduire à des erreurs coûteuses en termes de temps et d'argent, surtout dans les domaines complexes comme l'optimisation des performances, la concurrence et la sécurité. L'auteur remet en question l'idée que le recours aux robots est toujours négatif, soulignant que l'innovation et la compréhension sont essentielles pour résoudre de grands problèmes.

15:05

🧠 Le danger de la dépendance et de l'impuissance apprendue

Le script met en avant le risque de la 'dépendance apprendue' et de l''impuissance apprendue', où les développeurs peuvent devenir dépendants des outils IA pour résoudre des problèmes et perdre leur capacité à penser de manière créative et à trouver des solutions par eux-mêmes. Il est suggéré que les développeurs devraient éviter de devenir des 'robots' qui ne peuvent faire que ce que les robots peuvent faire et devraient instead se concentrer sur l'innovation et la résolution de problèmes plus vastes.

20:05

💡 L'importance de l'innovation et de l'indépendance de la pensée

Dans ce paragraphe, l'auteur plaide pour l'importance de l'innovation et de la pensée indépendante parmi les développeurs. Il suggère que les développeurs devraient être capables de générer des idées novatrices et de résoudre des problèmes complexes sans dépendre entièrement des outils IA. Il souligne que l'expérience de résoudre un problème et de parvenir à une solution claire peut être gratifiante et contribue à élargir les capacités de résolution de problèmes des développeurs.

Keywords

💡AI-driven tools

Les outils pilotés par l'IA sont des logiciels qui utilisent l'apprentissage automatique et d'autres technologies de l'IA pour faciliter certaines tâches. Dans la vidéo, ces outils sont discutés en tant qu'éléments qui peuvent améliorer la productivité des programmeurs, tout en soulevant des inquiétudes sur l'impact potentiel sur leurs compétences de base en programmation.

💡Productivité

La productivité fait référence à la capacité de faire plus de travail en moins de temps ou avec moins d'effort. Dans le contexte du script, l'accent est mis sur l'augmentation de la productivité grâce aux outils pilotés par l'IA, bien que cela puisse avoir des conséquences négatives sur les compétences des programmeurs.

💡Compétences de base en programmation

Les compétences de base en programmation comprennent la compréhension des structures de données, des algorithmes de base, de la résolution de problèmes et de la débogage. Le script aborde la crainte que l'usage excessive des outils AI puisse éroder ces compétences, entraînant une perte de détail et de compréhension profonde du code.

💡Code dependency

La dépendance au code fait référence à la pratique des développeurs de compter excessivement sur le code généré par des outils externes sans vérifier sa justesse, son efficacité ou sa maintenabilité. Dans le script, cela est discuté comme un risque potentiel lié à l'utilisation des outils AI pour la génération de code.

💡Autogénéré

Le terme 'autogénéré' se réfère au code ou au contenu créé automatiquement par un programme ou un outil, plutôt que manuellement par un être humain. Dans la vidéo, cela est lié au débat sur la fiabilité et la qualité du code produit par des assistants IA, et si les développeurs peuvent faire confiance à ces outils sans comprendre entièrement le code généré.

💡Révision de code

La révision de code est le processus par lequel un développeur examine le code d'un autre pour vérifier la qualité, la sécurité et la conformité aux normes. Le script mentionne que l'usage des outils AI peut réduire l'incitation à réviser ou à refactoriser le code, ce qui pourrait nuire à la qualité globale du codebase.

💡Propriétaires

Le terme 'propriétaires' se réfère aux outils ou aux services qui sont détenus et contrôlés par une entreprise ou une personne spécifique. Dans le contexte du script, cela fait référence à la dépendance des développeurs aux plateformes comme GitHub Co-pilot, ce qui peut créer des problèmes si les conditions de service changent ou si les frais deviennent trop élevés.

💡Expertise

L'expertise est la connaissance approfondie et l'expérience dans un domaine particulier. Le script discute de la manière dont l'utilisation des outils AI peut créer une fausse impression d'expertise chez les développeurs, qui peuvent se sentir compétents en raison de leur capacité à générer rapidement du code, sans nécessairement comprendre en profondeur le code qu'ils produisent.

💡Dépendance

La dépendance fait référence à la situation où une personne ou une entité repose excessivement sur quelque chose d'autre pour fonctionner ou réussir. Dans le script, cela est lié à la façon dont les développeurs peuvent devenir dépendants des outils AI pour générer, déboguer et optimiser leur code, au détriment de leur propre développement de compétences.

💡Innovation

L'innovation est le processus par lequel de nouvelles idées, des produits ou des services sont créés et mis en œuvre. Le script suggère que l'innovation est difficile sans une compréhension profonde, et que la dépendance aux outils AI peut limiter la capacité des développeurs à innover, car ils peuvent ne pas comprendre suffisamment le code qu'ils utilisent.

Highlights

AI-driven tools like GitHub Co-Pilot can reduce hours of work but may negatively impact programmers' skill sets.

There's a risk of erosion of core programming skills due to reliance on AI tools.

Shortcutting the learning process might have long-term consequences on programmers' abilities.

Language hopping and not regularly using a language can lead to forgetting fundamental details.

Problem-solving skills atrophy without regular practice.

AI assistants can lead to bypassing key learning steps like understanding algorithms deeply.

New programmers might not develop critical thinking skills necessary for programming due to AI assistance.

Senior developers are more skeptical of AI tools because they already have a strong foundation in programming.

Autogenerated code can lead to code dependency where developers rely heavily on AI-generated solutions.

Code generated by AI tools is updated more frequently, leading to a higher churn rate.

Autogenerated code may not always be optimal and can lead to inefficiencies or bugs.

Developers might not fully understand the code they use AI tools to generate.

AI-assisted code generation can lead to a lack of ownership and responsibility for the code.

Reliance on AI tools can create a false sense of expertise among developers.

Developers should not rely solely on AI-generated code to become better programmers.

AI tools can create a dependency on proprietary platforms, which may become too expensive or change their terms of service.

The use of AI tools might isolate developers from broader programming communities and open-source tools.

Learned helplessness is a significant risk when developers rely too much on AI tools for solutions.

Innovation is difficult without understanding, and relying on AI tools might hinder that.

Transcripts

all right why co-pilot is making

programmers worse at programming

September 11th 2024 nice thank you

Darren HS over the past few years an

evolution of AI driven tools like

githubschool

opers hours of work while these tools

have obvious benefits in terms of

productivity there's a growing concern

that they may also have unintended

consequences on the quality and skill

set of programmers

crazy it's funny that if you shortcut

the pain of learning that it might have

consequences that can't be right I mean

that that right that can't be right

right probably not I would just assume

that if you shortcut it it's it's it's

actually working smart and we all know

you should work smart not hard right

like why would you ever work hard that's

what AI are for I just work smart why

would you ever learn something you could

look up I refuse to learn how to do a

for Loop and go refuse never waste your

brain space um anyway sorry I just hate

I just put all the phrases together that

I hate and turn it into one 30 second

talk erosion of core programming skills

one of the most significant risks of

relying on tools like co-pilot is the

gradual erosion of fundamental

programming skills I mean this just

happens like anybody that does language

hopping that goes around and likes to

learn a lot of different languages you

know that this is just a fact of life if

you aren't on the ground programming it

you forget get all the little things

like yesterday I haven't programmed rust

in 8 months and so I opened it up to

just quickly import a library from rust

and do something and I forgot that you

have to first mod the thing and then you

can use the thing you know like you

forget all the little details you still

understand like the basics of it but

it's it's it's easy to forget the little

details and so when you actually do the

thing yourself you're just like crap um

shoot uh for is it in or is it of like

when TJ and I were doing co- programming

said in and it should have been of and

just that's simply because I haven't

done it you just you just forget the

little things and they're really easy to

rehydrate right but they're very easy to

forget and so when you do none of the

little teeny tiny things when it comes

to problem solving when you don't do

those hundreds if not thousands of

little problem solvings every day that

little problem solving atrophies

anything you don't do atrophies

completely normal no one should be

surprised by that take I think everybody

should just 100% uh agree like I can

look at rust code generally I can look

at almost any rust code that's not super

Advanced pin project ones and I can just

go oh yeah this is what's happening I

can still read rust code I just can't

program it off my T the tips of my

fingers that well in the past learning

uh to code involved Hands-On problem

solving debugging and deep understanding

of how code works at various levels from

algorithms to low-level implementation

details AI assistants while useful often

allow developers to bypass these steps

for instance rather than deeply

understanding the underlying structure

of an algorithms or learning how to

write efficient loops and recursion

programmers now just accept

autogenerated code Snippets over time

this could lead developers who can't

effectively solve problems without AI

assistance because they never fully

developed the problem solving and

critical thinking skills necessary for

programming I think this is why so many

senior devs were so into AI to begin

with we already all had this this notion

built into our head and so it was really

easy

to just go oh yeah this is right this is

wrong this is right this is wrong

whereas new people don't even have that

right new people don't even have that

that that that whole thing right and AI

made it really

easy and so I can see this being a this

was a problem for me and I I'll give one

more quick story uh when I was when I

was building a plugin with Lua is when I

kind of quit using co-pilot uh in I

forget what it was April maybe or March

I used co-pilot since the day they oh

the day they announced that Nat fredman

CEO at that time of GitHub gave me

personal access to GitHub all the way

until just last March so I used I used

it a lot I'm not saying oh I only used a

little bit I knew that I knew uh what's

his name the pope T Pope was writing the

plugin before co-pilot was even out like

I knew these things and so I knew neovim

was going to have a plugin I knew all

the stuff I was completely on board I

thought it was fantastic I was very

excited about it I still remember my

first experience having an llm generate

me code and and it

was absolutely

incredible but then when I turned it off

I realized I couldn't write a a for Loop

in Lua and that's when I was like all

right I got to stop I I've I've

accidentally handed my skills to

something else and I don't want to do

that now you could argue you do want to

do that because you believe that at some

point those skills are worthless due to

AI improving I'm saying hey I don't know

if they're going to get there anytime

soon so maybe you don't want to hand

them off quite yet this is not like a

phone in memorizing phone numbers this

is a little bit different you may not

want to do the same thing LSP does the

same thing in some level in LSP does do

the same thing over Reliance on

autogenerated code with tools like

co-pilot developers can quickly produce

working code without fully understanding

its mechanics this leads us to what is

known as code dependency where

developers learn too heavily on AI

generated Solutions without checking for

correctness efficiency and

maintainability uh by the way the

maintainability one is interesting there

was a study done that showed that code

generated between like 2018 to 2021

right before llms came onto the scene in

coding every line of code on GitHub on

average changed every six

months after llms up until this

point it's every two weeks on average it

just goes to show churn rate of lines

has greatly changed now I don't know if

that's

true universally I don't know how many

projects they looked at I don't know all

the things that they applied this study

to but it is a very interesting study

just by itself when you can produce code

faster you can get more churn and

correctness may be less

frequent one key with uh one key issue

with autogenerated code is that it may

not always be the optimal solution for

the specific problem with proper vetting

programmers might accept inefficient

buggy or insecure code that works at

first glance but causes problems in the

long run this Reliance reduces the

incentive to refactor or even review the

code which could harm the code bases and

team productivity over time yeah I mean

something that people don't talk about

is uh watch this watch this little thing

this is kind of like an interesting

thing uh Twitter feel free to

participate in as well press one if you

enjoy code reviews if you enjoy

reviewing code generally speaking it's I

would say about two-thirds probably are

not huge fans of it reviewing code I

think that's a pretty fairish statement

people generally don't like to review

code AS AIS go one that will be like as

the more you inte the more you integrate

with AI the more you're just reviewing

code you're not even writing code and

for me that's like such a hard trade-off

because I don't enjoy the process of

reviewing code I tend to not look as

closely when I review code and so when I

do that I find that I don't look as

closely as I should and I often let bugs

slip in with co-pilot I was never I was

never a great reviewer of code I've

never been a great reviewer of code some

people I feel like are just much better

at reviewing code I've never been good

at reviewing code I kind of always I

feel like I always have to bring things

down and run it and debug through it for

me to really get how someone else thinks

and why they do stuff like then then

helps me but I often review code and I

just find that I I miss easy bugs but

when I review my own code by the way

here's a pro tip a really big Pro tip

before you make a poll request load up a

diff on GitHub or on stash or whatever

process you use and look at your own

code and what you should you'll be able

to pick out so many problems and it's

because when you go onto GitHub or you

go onto stash you go into code reviewer

mode but then you already have your own

kind of you already have your full

understanding of the code and you will

find so many little things you go oh

yeah I see I dude I totally messed I

could do that way better oh I see that

oh I could definitely do that one better

right it's actually a really good

process to uh help improve yourself is

doing the difference between writing

your code and reviewing your code I I

and I don't believe and and and I know

some people say they can do it I don't

think you should do it from within your

editor you should do it in GitHub UI

because you you you switch modes because

if I do something within Vim I'm doing

it within my Vim my Vim mode I'm not

doing it within reviewer mode very

different experience yeah being able to

see your changes at once helps to see

what you've done yeah because I know you

can do that in vs code you can do that

in in Vim it's not hard to do it in Vim

I can look at diffs in Vim it's just the

fact that it's my mentality changes when

I'm on GitHub versus when I'm in my

editor and it's subtle and I try not to

like no matter how much you think you

can do it I don't think you can do it as

well because it's just it's just a

completely different like think about it

this way when you work in the same place

you always work it's really easy to be

in your work Zone but when you go and

work somewhere else

it creates a different feel right and so

if you go to a coffee shop to try to

only crank out code when you really need

the crank out code the once every week

or once every couple week trip to the

coffee shop is like your your raging

programming session and for whatever

reason you could just jump into it and

do it so well it's because you know

environment matters environment plays a

large role in how you think and do

things uh all right lack of ownership

and responsibility AI assisted code

generation can lead to the pH phenon

where developers become detached from

the code they write when a developer

writes every line of code manually they

take full responsibility for Its

Behavior whether it's functional

functional functional secure or

efficient in contrast when AI generates

specific portions of code it's easy to

shift the sense of responsibility onto

AI assistance I'm not sure I I guess I

don't feel that that's kind of it's a

unique take maybe people feel this I

don't really feel this but it's

interesting by the way I did say

something about LSPs and not learning

what I mean by LSPs and not learning

just so everybody understands is that

how many people know the standard

library of what they use really well or

have you offloaded the learning of the

standard library to your LSP so that it

autocompletes and um autocompletes and

shows you what it is I'm I think I think

LSPs are great by the way I love them

for navigation I love them for finding

references I love them for refactoring

uh as far as autocomplete itself goes I

think it it makes things easy so I use

it but I don't know if it's great right

like I don't know if it's always a

perfect win so it's kind of like a I see

both the benefit in the uh the

negativity I'd love to just have LSP

navigation oh that'd be so good uh when

a tool hands you the solution

immediately you're less likely to seek

alternative approaches also very fair

this is a very fair statement uh

experiment with different methods or

fully understand the trade-offs of

different implementations this

convenience while beneficial in the

short term reduces the number of

learning experiences that contribute to

long-term skill development this is fair

this is fair are you going no LSP as an

experience experiment uh I'll talk to TJ

and I'm going to see if I can disable

autocomplete and just disable

autocomplete and that's it keep

everything else but autocomplete I think

it'd be a lot of fun to really uh I

think it'd be really fun to be able to

still have like Auto Imports to be able

to still have refactoring still be able

to have jump to definition still be able

to have find references go to

declaration like go through all of those

things but not have auto complete cuz

navigation I think is really important

navigation is a fundamental time right

disable compy I'm going to play around

with it just disable neovim compy yeah

well I want I I'm curious the levels of

things I can do you know I've been I I

want to experiment with is that actually

good I don't know dependency on

proprietary tools another downside of AI

driven tools is the dependency they

create on proprietary platforms like

GitHub co-pilot when developers start

using these tools they become

increasingly reliant on them to generate

troubleshoot and optimize their code I

know I know there was uh for let's see

free for verified students teachers and

maintainers of popular open source

projects I want I want to say that again

free for verified

students I want you to ask yourself if

you are going to a 4-year University

that's going to teach you about data

structures where you have to program and

create data structures do you think

co-pilot is a net benefit or a negative

and what do you think that is with the

Reliance of them right here I think it's

negative

depends on you use it you're probably

right depends on how you use it if you

don't use it it's probably better than

if you use it but I I mean you do have

to realize that if you type the function

quicksort and then you start writing

each line will be autocom completed

perfectly According to some

implementation of quicksort I just think

this the dependence thing is kind of an

interesting argument which is this is a

form of selling you a product now you

could argue this is a good form of

selling a product I'm not saying it's a

good good or bad form I'm just saying it

is a form of selling a product and the

fact that they're intentionally selling

it to students for free there is

something about that that feels I'm just

saying it feels a little strange okay

it's like hey bro just come on it's just

a quick line of it's just like a little

quick line it's not a big deal you know

you're not just hey I wantan to I want

you to have a free night out on me okay

first drinks on me it's not a big deal

don't worry don't

worry uh this Pro this creates a problem

where the tools fail change their terms

of service or become too expensive

additionally this uh dependency on AI

tools can isolate developers from

broader programming communities and open

source tools that encourage peer

collaboration and knowledge sharing

further hindering their growth skill set

um I don't know if that I I I can't I

can't agree with this one in any sense

because I just don't see how that

happens the first one's free classic

yeah it's really is the first one's free

uh classic uh perhaps one of the most

concerning effects of AI code generation

is that it can create a false sense of

expertise among developers a developer

might feel proficient in a programming

because it can quickly generate or

because they can quickly generate code

with the help of co-pilot even though

they don't fully understand the code

this is actually a really really great

this is actually a really amazing

statement and I never thought about this

which is you can most certainly get this

idea that you are an expert when you're

actually not an expert like if you start

using rust and you find that you can

start kind of programming a lot of

things kind of easy you might you might

think that by the way I see I see myself

in this article even me who's good

enough I kind of feel this I feel this

is real uh do do we not feel the uh that

way about script kitties too no script

kitties are just attempting to cut and

paste and do what they got to do right

they're not attempting to become

programmers as far as I can tell they're

just using what they can to make

something happen and that's okay like if

your goal with programming is just to

make a product then you're going to use

the least the least friction path right

you will always choose the path to where

you're trying to learn it's just how it

goes so if your only goal is to produce

a product that works for people to use

you will probably choose the thing that

can produce the product as fast as

possible you're not thinking about

maintenance you're not thinking about

all the other stuff you're just choosing

the thing that is done so you could you

know so if you're using these things I I

I I actually really agree with this

because I also I also had the exact same

problem I was not as good at Lua because

I was using it all the time to generate

code like co-pilot was just generating

the code so I I just wasn't as good uh

this can be particularly dangerous when

developers move into more complex areas

of software engineering like performance

optimization concurrency and or security

especially security remember the last 10

years of software has been Rife with

security bugs GitHub has been trained

off the last 10 years of software put

those two ideas together okay where a

deeper understanding of the code is

critical without the foundational

knowledge developers can make mistakes

that are costly in both time and money

in short if you are a developer do uh do

not let's see if you as the developer do

not understand the code do not

understand how you got to where you are

do not understand how to solve the

problem yourself copying and pasting

code from an llm and being spoed F the

answer is not going to make you a better

programmer it's going to make you more

reliant on the robot and you will never

be able to do anything that the robot

can't already do cuz I think I think the

problem I have with this takeaway is

that why is it bad to rely on the robot

right if if people are correct we're

inevitably uh always marching towards

better and better llms then why is it

bad to rely on the robot and that's the

question you have to answer because it

doesn't matter that I don't like doing

that it that's the real question because

if if this is true if robots are always

going to get better they're going to

keep on getting better at the rate

they've been getting good at then why

does it matter and if you can't answer

that question then I don't think I don't

think your argument is worth a lot and

so even though you handed out all these

these these ideas which I think are

pretty good which is you know you you

have this uh reduced ability to kind of

uh you you have this dependency you

create a dependency you have a reduced

narrow thinking which I think is really

good this this narrowed critical think I

think is a really good section but in

the end you're only solving big problems

now you're not solving little problems

so why not just have the robot to it why

do you care if the robot does it so let

me invert it for a quick moment and and

try a different approach to this let me

let me get my words together the robot

can't innovate and innovation without

understanding is very difficult and

unlikely yeah Fair uh because if the

robot makes mistakes uh you should be

the one who judges well you could also

get an llm to explain errors that happen

remember that llms are really good at uh

explaining errors and so therefore you

could even use an LM to solve your

errors yeah I didn't realize this was

one of his articles I don't think pirate

software is a a hypocrite I think pirate

software has done really great things so

I don't think so uh disagree I would say

it this way one of the

worst aspects of programming in general

and one of the things that I think is

most destructive in people's careers is

learned helplessness where the problems

and the things you can solve you need a

definite answer

for I think llms can enhance that

problem and so perhaps does it matter

you understand all code I don't think it

I don't think it does matter that you

can that you need to understand all code

I think that code that is confusing to

you I think it could be really great if

you learned how to read it by having an

LM explain it to you I don't think that

there's anything wrong with that uh

maybe that would even help me move

faster in code I'm deeply unfamiliar

with the real problem comes to right

here you don't understand where let's

see you don't understand how you got to

where you are if you are helpless and

you constantly have to rely on something

else to tell you every single time the

steps you need to take you are creating

an unhealthy dependency you are offload

in your critical thinking and your

ability to solve problems larger than

small things in front of you right like

you probably know how to filter a list

of items based on ID or based on some

property you can do that but if you

can't see how to set these bigger things

up you know you have a blind spot so fix

the blind spot do not become helpless

for me llms and all this stuff I I don't

worry about most of it what I worry

about is learned helplessness it's that

everything you do this one false sense

of false sense of expertise is a form of

learned helplessness right dependency is

an obvious form of learned helplessness

not being able to think uh through

problems because you see a solution and

then you can only think of a solution

through one box is a form of learned

helplessness right you you just you turn

yourself into a smaller and smaller and

smaller and smaller point and I just

don't think that that is good flip take

that out the

name is be novel come up with you know

Ponder be inspired do the things that

make you great at being creative if

you've never like there is something So

Glorious about sitting there thinking

through a problem and then what feels

like a flash you can almost just see the

entire layout of kind of what you want

to build and then you got to go and

build that thing and that's an amazing

and great experience and it's something

that makes like it it makes it so that

you can have really big problems that

you can solve and you don't have to feel

so small or confined to just like the

space you're working in but you feel

like anything that you come across you

can get to a solution whether or not

it's the best solution and that's a

great place to be and I'm not saying

llms uh will take away or will make you

better or worse at that but if you only

rely on things to give you the answers

all the time it will make you worse the

ability to do that yourself is the skill

you're after and programming is the

expression of that

ability the name is the primen