Learning to Code in the Age of AI: Advice From a Top Udemy Instructor

Interviews JetBrains Academy

What should a beginner developer learn in order to keep up in the AI era? This is one of the most debated questions in tech right now. We got in touch with Ardit Sulce, a Python educator with over 650,000 students on Udemy, and talked about the value of struggling when learning something new, the changing role of teachers, the skills junior developers need, and why students should learn with professional development tools from the very beginning.

In this interview, we cover topics such as:

• How AI is changing the role of teachers
• When beginners should “tough it out” and when they should use AI
• Three skills junior developers need in the AI era
• Why you should learn in a professional IDE
• A three-stage path for learning to program with AI

The teacher’s role in the AI era

Q: Ardit, you taught programming before generative AI became part of the everyday development workflow. How have students’ expectations of learning programming changed?

Ardit Sulce: I teach programming mainly through video content. You’re not just hearing what a virtual environment is; you’re watching someone create one, activate it, and use it in real time. That format still works, and students still love it.

What has changed in the world of AI, though, is the number of questions I receive from students. I get 5–10 times fewer questions a day than I did before. When students get stuck, they just go to AI and get answers in seconds. Before, they would post the question in the course Q&A and wait hours for me or a teaching assistant to respond. That waiting is gone, so they stay in the flow of learning instead of stopping at every obstacle. The questions that still reach me tend to be the bigger ones: Which path should I take? Is this project good enough for my portfolio? How does this fit into the larger picture? etc. 

There’s one more expectation that’s new. Students now expect AI to be part of the curriculum. Before AI, a Python course was about Python. Today, learners want to know how Python and AI fit together, how to use AI tools to write code faster, but also how to build things with AI: apps that use language models, agents, automations.

A course that ignores AI feels outdated to them, and rightly so. That’s the biggest shift I’ve had to make as an instructor – not in how I teach, but in what I teach.

Q: If AI can answer those small questions instantly, what remains of the role of a programming course and teacher?

Ardit Sulce: As mentioned earlier, students can get answers to their questions instantly. However, when you know nothing about a topic, you don’t know what to ask. This is where a teacher is still crucial. A beginner doesn’t know that virtual environments exist, so they’ll never ask about them. They don’t know what they don’t know. 

AI is phenomenal at answering questions, but someone still has to know what questions are worth asking, and in what order. That’s the teacher’s job.

We always had good and bad teachers in school. Both had the same books and the same blackboard, yet with one of them the hour flew by, and with the other you counted the minutes. The good ones had an energy that made you curious to listen. This seems to be hard for AI to replicate.

When struggling helps you learn

Q: Learning to program has always involved frustration. Which parts of the struggle should AI remove, and which should it preserve? How can beginners tell the difference?

The mind has to struggle to absorb something new. You can take a programming book and read it casually at the beach, but you’re not going to learn anything from it. 

The confusion, the error messages, the twenty minutes spent on a missing colon – that’s not an obstacle to learning. That is learning.

One thing is for sure, though: Typing code by hand is going to be a thing of the past – but only among professionals. For students, the only way to understand programming is to do things by hand first. You need to write syntax to understand what you are doing. So the struggle of manually typing code is worth preserving for students, but worth eliminating for pros. It’s not about the task; it’s about what stage you’re at.

So how can a beginner tell the difference between struggle that teaches and struggle that just wastes time? My rule of thumb is simple: If the struggle is about understanding, keep it; if it’s just friction, remove it. Struggling to understand why your loop runs one time too many? Keep going – that’s how you learn. Fighting a broken driver installation, a cryptic setup error, or an outdated tutorial? Let AI handle it. There’s no lesson there.

Ask yourself, once I get past this, will I understand programming better, or will I just be back where I started? If solving the problem teaches you something you’ll reuse, struggle through it yourself. If it’s a one-time roadblock, hand it to AI. Beginners tend to get this exactly backward. They let AI write the loop, then spend an evening fighting the driver. It should be the other way around.

Q: If working code is no longer sufficient proof of learning, what should educators and employers look for instead?

Ardit Sulce: Honestly, working code was never good proof. It was just the cheapest thing to measure. Students copied from Stack Overflow long before ChatGPT existed, and every teacher knew it. AI didn’t create the problem. It just made the shortcut so fast and so clean that we can’t ignore it anymore.

The first thing I look for is whether the student can explain the code – not with formal terminology, just plain questions: Why is this a dictionary and not a list? What happens if this file doesn’t exist? Why is this chunk of code inside a function? What would break if I moved this line above that one? If a student used AI to write the code but can answer questions like these, they learned something. If they can’t, they merely “delivered” something.

I’d advise employers to do roughly the same thing. Stop asking job candidates to build; ask them to review. Hand them a file of AI-generated code with a subtle problem in it – an off-by-one, a silent exception swallow, a function that works but does the wrong thing on empty input – and see whether they notice and how they explain it. Or sit with them and debug something face-to-face. Watching how a person narrows down a problem tells you more in twenty minutes than any take-home assignment ever did.

Skills junior developers need in the AI era

Q: What skills will help early-career developers stand out?

Ardit Sulce: I would focus on three.

1. Reading code you didn’t write

Writing is cheap now; judging is the job. You’ll spend your days looking at code that came out of a model and deciding whether it’s good, does what you asked, and holds up when the input triples. Most beginners have never really read code – they’ve only written it. Flip that around: Read codebases on GitHub, revisit your old projects, and read what the agent produces instead of blindly accepting it.

2. Saying precisely what you want

We used to write programming. Now we “speak” programming, and most people are terrible at speaking it. They say, build me a login system, get something generic, and blame the model. A good prompt is a specification: what the code does, what it must not do, what happens at the edges. We used to call this “requirements”, and it used to be someone else’s job. Now it’s the main interface.

3. System-level understanding

And the third is exactly that system-level understanding I described above – knowing what an app is made of and how the pieces fit together. There’s no shortcut here, and that’s why it’s the differentiator. 

Learning with professional tools

Q: Your latest video course, Gen AI Engineer Bootcamp, is paired with hands-on practice in PyCharm. What can learning in a professional IDE add in the AI era?

Ardit Sulce: Video is passive by nature. There’s a gap between I watched someone do that and I can do that. You have to get your hands dirty and code in an IDE. That’s why the Gen AI Engineer Bootcamp Udemy video course is paired with hands-on practice in PyCharm – I didn’t want people to finish a lesson feeling like they understood it. I wanted them to immediately be in the same place I was, with the same tool, figuring things out firsthand.

There’s also a more practical reason. 

Then there’s what you get from writing, running, debugging, and modifying code – none of which a video can give you. Writing reveals which parts you only thought you understood. Running exposes you to the real environment: dependencies, virtual environments, package versions, configuration files, API keys, and tracebacks. Debugging teaches you to investigate instead of starting over. And modifying code shows whether you understand the project well enough to change it without breaking something else.

That final step is particularly important in the AI era. Generating an initial version of an application is becoming easier. Understanding existing code well enough to change it safely remains a real skill.

The new learning path for junior developers

Q: Based on all of this, what should the learning path look like for someone starting today?

Ardit Sulce: This question has concerned me since it became clear that generative AI could produce complete scripts. The interface is changing. Previously, developers expressed instructions mainly by writing programming languages. Now, they can also describe their intent in natural language and ask an agent to implement it. But programming is still the common denominator. You still need to understand how a program works, how data moves through it, how the components fit together, and how to determine whether the output is correct.

Syntax may be getting easier to produce. Understanding the system isn’t.

I would divide the learning path into three stages.

1. Writing syntax by hand. Write real code, i.e. small programs, in a proper IDE. Not because you’ll do this at work, but because this is where the mental model gets built: what a variable is, what a loop does, how data flows through a program. Don’t skip this stage.

2. Using AI as a tutor. Move to projects of increasing size, with AI explaining what you don’t understand along the way.

3. Using AI as a co-worker. Let AI write parts of the code while you review what it produces. Each project should be slightly bigger than the last: a script, then an app with a database, then something with users, something deployed, and something that talks to an API. That progression is what turns syntax knowledge into system knowledge.

The old way was to spend years mastering syntax and hope the architectural understanding shows up along the way. The new path is shorter but flipped: learn enough syntax to understand what’s happening, then focus on understanding systems – because that’s the part you’ll actually be paid for.

Manual coding is your homework while you’re still in the learning phase. Then, when you start your career, you’ll be ready for the architect’s work. Someone starting today isn’t at a disadvantage compared to those of us who spent twenty years coding manually. They’re skipping a stage that, frankly, was never the point.

We want to thank Ardit for sharing his experience and perspective on teaching and learning programming in the age of AI.

Are you a programming course creator interested in making your courses more hands-on with professional development tools? We’d love to explore ways to collaborate – whether you already use JetBrains IDEs or are considering bringing them into your teaching.

Through the JetBrains Course Creators Program, we support educators with tools, resources, and opportunities to reach more learners. Explore the JetBrains Course Creators Program or contact us at education@jetbrains.com.

The JetBrains Academy team