Forem: Julia Amatuni

Should You Use AI to Learn to Code?

Julia Amatuni — Tue, 19 Aug 2025 17:00:17 +0000

I’ll start by acknowledging that you probably already do.

And honestly? We get it. Programming is hard! Learning materials can be poorly structured and lack good visualizations. Sometimes your teacher is a math genius who is bad at talking. And hey, AI is pretty capable for beginner-level problems. It can make the implementation much faster for some learners, but for others it can actually make everything worse.

This post isn’t meant to wag fingers or shame anyone. We just want learners to be smart about the way they use new technology – especially one as impactful on the learning process as LLMs. Indeed, sometimes getting the best learning experience may mean not using AI, but sometimes it just means using it slightly differently.

This is part three in our series How to Learn to Code in an AI World. Don’t miss the first, Is it Still Worth Learning to Code?, and second, Learning to Think in an AI World: 5 Lessons for Novice Programmers.

Let’s get right to it: Should you use AI when learning to program?

Our answer is best expressed as a graph:

In short, the more of a beginner you are, the less you should use AI to generate code for you.

There are a lot of reasons for this, namely:

Skipping the basics makes understanding harder concepts more difficult.
You accept more bad suggestions because your code reading skills are not developed.
It speeds you up, which is good for productivity but bad for knowledge retention.
You feel less ownership over your work, which decreases motivation.
The experience of programming becomes “flatter” – a solution given to you is less satisfying than one you worked for.
It messes with your perception of how much you know.
You lose self-confidence and feel like you can’t code without AI assistance.
You develop delusionally high self-confidence, where you feel like you’re a great programmer, even though AI is doing most of the work, and you barely understand how a for loop works.

This doesn’t mean you can’t use AI to help you follow your curiosity and increase your motivation to learn things yourself. You can ask it to generate metaphors for challenging abstract concepts, ask questions if no human teacher is available, clarify terms that confuse you, and even get advice on a personal project that is slightly out of your depth.

If positive reinforcement isn’t working, try asking your AI to be mean to you.

Still, we would generally advise caution when interacting with LLMs that aren’t specifically tailored for education. Research shows people are very bad at realizing when AI is replacing their thinking rather than augmenting it.

Choosing between no AI, an AI made for learning, or going all in is difficult. In the next part, we’ll go a bit deeper into the pros and cons of each of these options.

Non-AI materials and tutors
Inconvenient, but better for knowledge retention and accuracy

Non-AI materials require us to commit to the active process of digging through books, documentation, and forums to find answers. It can take much longer compared to prompting an LLM, but the benefit is that it fully engages us in our own learning (as long as it doesn’t ruin our motivation by being too boring). Our brains interpret the additional time as a sign of importance, which in turn enhances our memory of what we learned. Moreover, we might stumble upon unexpected gems in a way that’s difficult with AI-generated answers.

Let’s also not overlook the human element here: a skilled teacher can offer a personal perspective that significantly outweighs the convenience of AI. Through good teachers we learn to love a subject and believe in ourselves, profoundly impacting the experience of learning and our long-term motivation.

Take, for instance, our completely human-made animated guide to Git!

AI tutors
Extremely convenient but hard to get right in practice

Usually, when we interact with AI, we’re looking for a quick and easy answer. Even when it’s engineered to prompt us to do some thinking on our own, we tend to unconsciously skip over those questions and shortcut to the solution. It requires a lot of willpower to slow down and truly digest the information AI gives us, not to mention reflect and relate it to previous things we’ve learned, and finally, understand how to apply it in practice.

If you’re good at making yourself slow down and think, then tutor away! But, if you find yourself spending most of your time prompting, skimming, and rushing toward output – skipping the high-level thinking parts of coding – then we’d recommend you take a break from AI and find ways to allow for more thoughtful reflection into your practice.

AI tutors can help spark your curiosity if you’re having trouble connecting with the material.

AI assistants
Great for doing things, less great for learning things; to use them wisely requires a strong foundation

There are as many opinions on the best way to use an AI assistant as there are software developers. Some use it every time they code and some prefer a whiteboard and a rubber duck. Over time you’ll learn your preference and style. The important thing is for you to figure out how to write quality code quickly and in a way that feels good.

If you do use it, we definitely recommend spending some focused time learning best practices – like any technology, it takes some intention to learn to use it well. See our course catalog for free courses like Coding with AI assistant or Prompting to debug and fix AI-generated code.

Code completion should only be used when you’ve developed a strong foundation.

In summary, while AI tools are incredibly convenient, it’s crucial for beginners to exercise caution. Overreliance on AI for code generation can hinder foundational understanding, knowledge retention, and intrinsic motivation.

The best approach involves balancing AI assistance with traditional learning methods, fostering computational thinking, and staying smart about when you use it. Ultimately, the effectiveness of AI in your coding journey depends on your learning style, current skill level, and how thoughtfully you integrate these powerful tools.

Learning to Think in an AI World: 5 Lessons for Novice Programmers

Julia Amatuni — Tue, 10 Jun 2025 10:25:37 +0000

This is the second article of the series How to Learn to Code in an AI World. Don’t miss the first, Is it Still Worth Learning to Code?

Imagine the following scenario:

A student is enrolled in an introductory computer science course. They have no previous programming experience and don’t consider themselves very good at math or technical subjects. In this course, the teacher allows the use of large language models like ChatGPT and AI code completion software to help students with their work.

When completing a homework assignment, the student carefully reads the prompt and begins to code. Almost immediately, an AI code suggestion tool generates a long function, which overwhelms them, prompting them to turn to ChatGPT instead. Believing it’s best to use AI as a tutor rather than an answer machine, they request step-by-step guidance. However, after reading the first point of advice, they scroll past the explanation in search of a quicker solution and copy the generated code. This code, however, does not fully match the problem and contains unfamiliar syntax, leading to confusion. After repeatedly passing their code back and forth between the IDE and ChatGPT, they eventually produce a version that passes the test cases, though without fully understanding how it works.

When asked later about how useful they found the AI, they answered “very” and appreciated its utility as a personal tutor in a class they struggle in. They lack awareness of the way they actually use the AI and have a skewed perception of their understanding of the material.

Now imagine another student in the same class. She once attended a STEM-focused summer camp and is familiar with the frustration of learning to code. She does not find it easy, but has the experience behind her to know she is capable of producing working output.

When completing the same assignment, the student carefully reads the problem description and begins structuring her solution by naming variables and adding comments to outline her approach. As she types, the AI-powered code suggestion tool provides frequent input, which she occasionally glances at but mostly ignores, preferring to follow her own plan. When she does accept suggestions, they are small and deliberate – filling in predictable elements like closing brackets or simple conditionals. While she encounters a few syntax mistakes, she methodically corrects them and successfully completes the assignment, passing all test cases in a short time. Looking back, she acknowledges that AI helped her move faster but credits her own structured thinking for getting to the right solution.

The example above is not hypothetical. This scenario was illustrated in a 2024 study about AI’s role in the widening gap between struggling and non-struggling students. Although it may seem counterintuitive, the emergence of AI being there at any moment to write code for us might mean an increased emphasis on writing more of it by hand, at least in the beginning.

Considering this, we’ve introduced several AI-powered features in our plugin, including machine translation for course content, theory lookup, and AI hints. The goal is not to avoid AI entirely but to learn how to think effectively alongside it. The following five lessons will help you develop the skills and practices you’ll need to navigate AI tools and become a stronger, more independent programmer.

If you missed it, read part one of this series: Is it Still Worth Learning to Code?

Focus on problem solving, not output

Pauses in programming are useful, even if they feel like getting stuck. Novice programmers are often surprised at how much time will go into a single function or even a single line of working code. This slow and often frustrating process is necessary for building the kind of cognitive processes you’ll need to become a better programmer.

Refining your thinking will also improve your ability to quickly read and understand code you haven’t written yourself. While this has always been important for collaboration, now that we have AI code assistants, developers are reading a lot more code than they used to. If a large-language model autocompletes your function, you want to be able to quickly accept or reject the suggestion without getting caught up in understanding the logic of it.

Hack your own psychology

If there’s one idea that should leave the gated garden of research and make its way into classrooms immediately, it’s the concept of meta-cognitive awareness. Granted, the reason it hasn’t is probably because “meta-cognitive awareness” is not a very enticing term – but the idea is quite simple. It’s about your ability to recognize “thinking traps” and effectively problem-solve your way out of them.

Research has shown that teaching beginners about these challenges produces immediate and lasting changes to the students’ productivity, independence, and confidence. Given that, it might be good to take the time to learn them!

Here are a few meta-cognitive difficulties or “thinking traps” common in programming:

Right question, wrong answer (Forming) – You understand the problem, but you’re using the wrong approach to solve it.
Stuck in a Rut (Dislodging) – Even when you realize your approach isn’t working, you struggle to change it.
Wrong question, right answer (Assumption) – You perfectly solve a problem… just not the one you were supposed to.
So close, but so far (Location) – You zoom through the steps too fast, thinking you’re almost done, only to realize you skipped something crucial.
Band-aid on a broken bone (Achievement) – You keep making small fixes in hopes your code will start working, but actually, it needs a total overhaul.

Interestingly, researchers found that rather than helping with these challenges, AI actually introduced new meta-cognitive difficulties for beginners. Namely,

Falling Behind Without Noticing (Progression) – You think you’re keeping up with the course, but because AI assistance can generate working code that surpasses your current understanding, you’re falling behind and don’t realize it.
Distracting Pop-Ups (Interruption) – Every time you try to focus, an AI code-completion tool throws a suggestion at you, breaking your train of thought.
Following bad advice (Mislead) – You trust a suggestion (from an AI, a tutorial, or even your own guess) that seems right but actually takes you in the wrong direction.

At the moment, most AI tools are not built with these challenges in mind. Even if they were, you are the sole expert of your own mind, and there is only so much an external resource can do to see the traps in your thoughts.

Don’t rush too quickly towards ill-conceived code

Although it looks good in the movies, speed-coding is unproductive for learning. Much of getting through your first programming assignments involves taking the time to understand the problem and then properly strategizing a solution. Both of these are mental processes and should be done before you start coding! While it’s satisfying to generate a lot of code very quickly – in practice, the faster you write the code, the more time you have to spend debugging it.

Don’t make the classic mistake of grinding through a vague idea until you’re left with a steaming pile of broken syntax and semantic errors you’ve put five hours into debugging and are too invested in to rebuild the right way. Much of that time would be better spent working out the data structures and program architecture before you write a single line. Once the logic of your program is solid in your mind, implementing it just becomes a matter of syntax.

Take steps to avoid the illusion of competence

Many novice programmers in the study above confidently believed they had solved a programming problem using AI tools, but missed the central lesson of the assignment. This unwarranted confidence, described as an illusion of competence, was compounded by the fact that using too many AI suggestions contributed to a lack of awareness of what was holding them back.

Research uses the term self-efficacy to describe the confidence people have in their ability to complete specific tasks. A healthy level of self-efficacy fosters persistence and engagement, but when you overestimate your abilities, you may neglect critical reflection and fail to address gaps in your knowledge.

While the illusion of competence can occur regardless of the tools used, AI can amplify it. By providing ready-made suggestions or solutions, AI might give you the false impression that you have mastered a concept, even if you struggle to apply it independently.

Here are some suggestions for avoiding this illusion in your own learning:

Prioritize active learning above all else: Writing code, debugging, and breaking down problems actively engages the brain more than reading or copying solutions. This engaged state is the key to activating the neural circuitry necessary for learning.
Try rubber duck debugging: Instead of going to an AI assistant when you get stuck, try the tested and true technique of rubber duck debugging, where you attempt to explain what the faulty code is doing, step by step, out loud. This technique helps you translate a vague intuitive understanding into concrete sentences, which almost always helps you see what needs to change.
Teach a beginner what you’re learning: Even if you only know the basics, teaching someone else to program is genuinely one of the most underrated educational tactics there is. Novices usually ask questions that can reveal bigger ideas about the material you may have missed.
Code replays and critique: Anything worth doing is worth doing well. Seeking out peer reviews, instructor feedback, or even automated tools that offer detailed critiques can highlight areas of misunderstanding. This extra step will pay off.
Reframe mistakes as “negative expertise”: Even if your DIY code is rife with bugs and flawed approaches, learning to be a good programmer is as much about knowing what doesn’t work as it is about knowing what does.
Build confidence without sophisticated tools: Challenge yourself to solve your next assignment without using an LLM or stack overflow. By depriving yourself of easy answers, you build stronger coding muscles. You may go back to the tools eventually, but these sessions can help build confidence and awareness of your understanding.

Understand the emotions of learning

All coders know that the mind of a programmer often oscillates between two extremes: there is either the ecstatic rush of implementing perfectly working code or overwhelming, frustrated confusion. Whether you’ve been coding for a week or a lifetime, this emotional experience is pretty much the same. The trick is to learn to work with and through these experiences, not against them.

To truly sustain your programming practice, you should work to foster true confidence, develop a productive response to frustration, let yourself be inspired to play and be creative, and take satisfaction and pride in your work. Understand that these are almost more important than the information you study, because they determine your attitude to programming. Developing and maintaining the belief that **you are someone who enjoys programming **will serve you well beyond the ability to work out each step of a sorting algorithm by hand.

This is the second post in our series How to Learn to Program in an AI World, keep an eye out for the next ones on our blog in the coming months. If you missed it, check out part 1: Is it still worth learning to code?

Is It Still Worth Learning to Code?

Julia Amatuni — Fri, 16 May 2025 09:33:05 +0000

by Clara Maine

During a time when many companies (including JetBrains) are embracing AI for developer productivity, the JetBrains Academy is not integrating big LLM, JetBrains AI Assistant is not being marketed toward beginners, and we are even considering disabling AI features in beginner programming courses by default at the request of our learners.

These choices may seem strange. Shouldn’t students be learning to work with these tools from the beginning? Shouldn’t they be adapting to our new AI world?

Our choice to move slowly and thoughtfully with regards to our educational AI features is intentional and assisted by our incredible research team. We recognize that LLMs can be incredibly useful to aid understanding of new concepts. However, we also think it is important to understand how these tools help and hurt learners, because there is good evidence they have the potential to do both.

In an effort to help guide learners during this time, we wrote four blog posts about learning to code in an AI world. This is the first in the series, keep an eye out for the next ones on our blog in the coming months.

Is it still worth learning to code?
What is computational thinking and how can you develop it?
How will careers in programming evolve with AI?

Is it still worth learning to code?

Yes. Aside from its current utility in building software, coding builds computational thinking, strengthens problem-solving skills, and reinforces abstract concepts that are important in many disciplines. Programming skills help demystify the digital worlds we inhabit while giving you the power to actively shape and contribute to them.

Most experts expect AI to augment future programming jobs, not replace them. Although AI-generated code is becoming increasingly prevalent, skilled people still need to review, debug, and take accountability for the quality of said code. How much of a technical foundation will they need to be able to do that? The safe answer is everything a traditional coder knows. Organizations are willing to pay for this level of expertise because, ultimately, deep knowledge and experience serve as risk mitigation in the face of evolving technology.

Even in a future where software development can be completely automated with a prompt from someone with no technical knowledge, programming is an excellent exercise in a specific kind of thinking. In learning to solve problems computationally, we develop new ways of seeing. With this new set of eyes come new ways to make positive change in the world. This applies to both the physical world we inhabit (notice how many daily inconveniences might be solved by a simple program) and the digital ones (notice how software could be made better).

No matter how good the machines get, their adoption is guaranteed to be a long and messy process. Success in navigating this ever-shifting landscape will depend on your ability to adapt to new technology, and robust computational thinking skills will make that process much easier.

What is computational thinking and how can you develop it?

Computational thinking (sometimes called algorithmic thinking) is a name for the cognitive skills we build when we program. It involves breaking down complex problems into smaller, manageable parts, identifying patterns, and designing step-by-step solutions that can be implemented with code and algorithms.

Even introductory programming courses naturally develop basic computational thinking. By writing programs to automate tasks, analyze data, or solve challenges, students learn to think in structured, algorithmic ways.

If you want to level-up your computational thinking beyond the basics and prepare for the challenges and opportunities of this new era, consider exploring courses that focus on algorithms and data structures. While they seem less practical than courses about specific tools and frameworks, the thinking tools these courses develop will last decades longer than any library or framework which is currently in vogue.

Our educational research team is also using our open-source plugin to build Cognifire, a low-code learning environment to help students develop their computational thinking. Keep an eye on our newsletter for more information about that in the coming months!

If you’re at the beginning of your learning journey, just remember that the challenges and frustrations you encounter when you’re programming are productive in the context of developing these intangible skills and intuitions you’ll need to master programming. Always keep in mind that developing this skill requires practice, reflection, and an openness to facing difficult problems that stretch your mental models.

How will careers in programming evolve with AI?

The general consensus is that developers will increasingly validate, debug, and communicate about AI-generated code. This will require a deep foundational knowledge, since it’s hard to efficiently debug code you couldn’t have written yourself.

At the moment, AI models struggle with broad-scope problems like identifying how changes in one part of a large codebase might affect other interconnected parts. They perform poorly with niche frameworks and tools, lack consistent creativity and deep domain expertise, and only really work if the prompter has given clear and detailed instructions, which is a skill in itself.

With time, it’s true that many of these shortcomings will improve, but which and how much is hard to say. If there is one thing we do know, it’s that automation is not new to programming, and AI is just another form of it. The job of “programmer” has evolved from doing complicated math by hand to punching machine code into cards, to writing assembly languages, then high-level languages – not to mention adapting to new IDEs and general tools like Git. Learning from history, we see that the tools always change, but the opportunities for people with technical knowledge and high-level reasoning skills continue to flourish.

Looking into the future, we can expect the same dynamic: the robots are best used for repetitive, predictable work, and everything else will be handled by people. Put concretely, gone are the days of abundant programming jobs with relatively simple, repetitive, and mundane responsibilities.

So, does that mean junior developers will be more easily replaced by AI?
While it’s true that roles and duties may change faster for inexperienced programmers than for others, that is because more (but not all) of their responsibilities involve wrestling with the boilerplate code that AI can generate most reliably. This doesn’t mean juniors are going to be replaced by AI – it just means they might spend slightly less time writing code, and more time thinking about it.

This is the first post in our series How to Learn to Program in an AI World, keep an eye out for the next ones on our blog in the coming months.

Explore JetBrains Academy courses that you can complete in your IDE.