Why CoPilot Is Making Programmers Worse
Summary
TLDRCe 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
🤔 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.
🔄 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.
🚫 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.
🧠 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.
💡 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.
Mindmap
Keywords
💡AI-driven tools
💡Productivité
💡Compétences de base en programmation
💡Code dependency
💡Autogénéré
💡Révision de code
💡Propriétaires
💡Expertise
💡Dépendance
💡Innovation
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
Ver Más Videos Relacionados
Skills-Based Organization: What Works, And Twitter vs. Threads
AI in Healthcare: The Next Frontier | Leonardo Castorina | TEDxUniversityofEdinburgh
La vie des sols
Why Women DON’T Want Men That Are DISCIPLINED And Stoic!
Ce qui se cache derrière le fonctionnement de ChatGPT
Le danger des ondes de nos téléphones.
5.0 / 5 (0 votes)