Goal

Tutoring Strategies: The goal is to understand how LLMs can facilitate interactive and personalized learning in Python programming. Students will learn to use LLMs to analyze code, interpret syntax and semantics, and address error messages through their interpretation and debugging suggestions. They will also design prompts to receive hints rather than direct answers, and leverage LLMs to create additional questions and tasks to reinforce learning of the key concepts.

The long-term goal is to learn how to program independently and use LLMs to enhance the efficiency. To use AI-generated help effectively, it’s important to first build your own programming skills. By practicing coding yourself, you’ll develop a solid foundation, improve your problem-solving skills, and become more self-reliant. Understanding the details of Python programming without overly depending on LLMs will prepare you to use LLMs more effectively as a helpful tool. Otherwise, you will be a copy-pasta pirate without any understanding of what you are doing.

Analogy: Imagine you’re trying to build muscle and get stronger. To do that, you can’t just watch someone else lift weights at the gym and expect to see results in your own body. The real progress happens when you put in the effort yourself and gradually increase the resistance as you grow stronger. The more you challenge yourself, the more muscle you’ll build over time. Now, think of learning programming in the same way…

Terminology

Overview

When you start learning programming, you may find some technical terms unclear or confusing. Textbooks often include glossaries that explain these terms. Additionally, you can use an LLM to:

provide an explanation,
rephrase an explanation to suit your understanding,
illustrate concepts with examples,
clarify differences between similar terms.

1: Explanation

To understand a specific term T, you can use this prompt:

Can you briefly explain T at my current programming level?

For instance, you might ask for an explanation of ‘machine code’ this way:

Can you briefly explain ‘machine code’ at my current programming level?

2: Rephrasing

If the explanation E is unclear, you can ask the LLM to simplify it:

I read that T is E but I find it confusing. Could you provide a brief and simple explanation to help clarify this for me?

For example, if the the explanation of the ‘machine code’ as the lowest-level language for software, which is the language that is directly executed by the central processing unit (CPU) is too complex, you can ask for clarification:

I read that ‘machine code’ is the lowest-level language for software, which is the language that is directly executed by the central processing unit (CPU) but I find it confusing. Could you provide a brief and simple explanation to help clarify this for me?

3: Examples

To deepen your understanding, you can request examples:

Give me an example of T

For example, we may get an example of the ‘machine code’:

Give me an example of ‘machine code’

4: Differentiation

If you’re confused by similar terms, ask the LLM to explain the differences:

I read about T1 and T2 . I want to be able to use the terms precisely, but I do not fully understand the difference between them. Can you explain it shortly in simple terms?

For example, if you are learning ‘main memory’ and ‘secondary memory’ (glossary), this approach can help clarify the distinctions.

I read about ‘main memory’ and ‘secondary memory’ . I want to be able to use the terms precisely, but I do not fully understand the difference between them. Can you explain it shortly in simple terms?

Another terms you may try are the interactive and script mode, a syntax, logic and semantic errors, a parameter and an argument, a function and a method.

5: Quiz

To ensure active learning, you may ask an LLM to generate a quiz to check if you understand the terminology:

Please create a quiz to check my understanding of T1 and T2 . Additionally, check if I understand the differences between those concepts.

For example:

Please create a quiz to check my understanding of ‘main memory’ and ‘secondary memory’ . Additionally, check if I understand the differences between those concepts.

Platform Awareness Hint: Gemini https://gemini.google.com/ and Gemini Notebook https://notebook.google.com/ have nice interactive quiz mechanisms.

Exercise

You may try the provided example prompts, take terms from an example glossary.

A basic task: Pick a term you found confusing in this course and work through Explanation, Rephrasing, Examples, and Differentiation (1-4) with it.
A reversed task: Ask the LLM to quiz you (5: Quiz) on two terms you think you already understand well, to check whether your understanding actually holds up.

Reflection

Take a few minutes to reflect on this activity. If possible, exchange your observations with a peer – you may each have noticed different things.

Adaptations: Did this activity need anything from your tutor role prompt (Setup) that you hadn’t anticipated – a new instruction, more context, a different structure?
Spot the 4D: Which of Delegation, Description, Discernment, Diligence – and which specific part of it – did this activity mainly exercise? Where do you see a loop (Delegation-Diligence or Description-Discernment) at work?
This activity: Which of the five request types (Explanation, Rephrasing, Examples, Differentiation, Quiz) got you to genuine understanding fastest, and which felt like it just gave you an answer to memorize?

Code Interpretation

Overview

Just like in natural languages, reading code is generally easier than writing it. That’s why we’ll begin this workshop by reading existing source code. Additionally, a significant part of programming involves understanding and analyzing source code. We will use top-down approach to understand a given program.

Context (code)

As an example, we will use a program from the first session of 198801, which is a modified version of the example from the Python for Everbody textbook.

text = [
  "It is easier to fix the problem with a program which is not working at all",
  "then to identify and fix a problem with a program which is working but incorrectly."
]

counts = dict()

for line in text:
    words = line.split()
    for word in words:
        counts[word] = counts.get(word, 0) + 1

bigcount = None
bigword = None

for word, count in list(counts.items()):
    if bigcount is None or count > bigcount:
        bigword = word
        bigcount = count

print(bigword, bigcount)

1: Purpose

At first, we may ask for the purpose of the course code.

As my personal tutor, your task is to take the code snippet provided and explain it in simple, easy-to-understand language. Break down the code’s functionality, purpose, and key components. Use analogies, examples, and plain terms to make the explanation accessible to someone with my current coding knowledge. Avoid using technical jargon unless absolutely necessary, and provide clear explanations for any jargon used. The goal is to help the reader understand what the code does and how it works at a high level.

Please help me understand the given CODE. I will always refer to it as CODE. Here is CODE:

text = [
  "It is easier to fix the problem with a program which is not working at all",
  "then to identify and fix a problem with a program which is working but incorrectly."
]

counts = dict()

for line in text:
    words = line.split()
    for word in words:
        counts[word] = counts.get(word, 0) + 1

bigcount = None
bigword = None

for word, count in list(counts.items()):
    if bigcount is None or count > bigcount:
        bigword = word
        bigcount = count

print(bigword, bigcount)

Please explain to me briefly, in one sentence, what is the purpose of CODE.

2: Visualization

For most learned, a visualization helps in understanding. It is the best to do it yourself, but you can use an LLM to create it for you.

Prompt

As my personal tutor, please help me to understand the CODE providing its visualization. Generate an UML-like Python code flowchart of the CODE.

text = [
  "It is easier to fix the problem with a program which is not working at all",
  "then to identify and fix a problem with a program which is working but incorrectly."
]

counts = dict()

for line in text:
    words = line.split()
    for word in words:
        counts[word] = counts.get(word, 0) + 1

bigcount = None
bigword = None

for word, count in list(counts.items()):
    if bigcount is None or count > bigcount:
        bigword = word
        bigcount = count

print(bigword, bigcount)

Output

Platform Awareness Hint: the quality of a generated image can vary significantly between platforms. As of 2026, an unpaid version of OpenAI/ChatGPT delivered a meaningful visualization (image below). If you get an inaccurate visualization, you can try another LLM or ask the LLM to generate a flowchart code and use it in an online visualization tool (hint below).

Example visualization

Workaround hint

Ask for textual definition instead of an image.

As my personal tutor, please help me to understand the CODE providing its visualization. Generate an UML-like flowchart in PlantUML syntax https://plantuml.com/

text = [
  "It is easier to fix the problem with a program which is not working at all",
  "then to identify and fix a problem with a program which is working but incorrectly."
]

counts = dict()

for line in text:
    words = line.split()
    for word in words:
        counts[word] = counts.get(word, 0) + 1

bigcount = None
bigword = None

for word, count in list(counts.items()):
    if bigcount is None or count > bigcount:
        bigword = word
        bigcount = count

print(bigword, bigcount)

Use https://editor.plantuml.com/ to render an image.

3: Semantics

Once we know what the program is doing we may look into the details.

Depending on your level, you may either ask an LLM for details (1) or try to figure out the meaning of particular parts by yourself (2).

Novice

If you are a novice, for the first task, it would be easier to start with passive learning to get an explanation and next, examine your comprehension. For this purpose you may use the following prompts.

Now, please give me more details about the semantics of particular parts of CODE.

As a response, we may expect the code to be split into chunks together with their explanations. Next, we may ask for more details

Please give me more details about component 3.

After reading the response, we may request understanding questions:

I think I understand this. Could you ask me a few questions to check if I got important points?

Answer questions or ask for correct answers. Repeat the steps till you achieve the desired level of understanding.

Advanced

If you have programming skills, you may go for active learning starting with the following prompt.

Now, I want to figure out myself what is the purpose and meaning of particular lines of the CODE. Please lead me through this process with questions and hints.

4: Comments

Before finishing the conversation, we may ask the LLM to provide us with a version of the code containing explanation comments, especially for parts that were unclear to us. We may store this version on our computer for the future reference.

Please add explanatory comments to CODE. In general, use brief explanations except for the more difficult parts for me to understand.

You may be more specific about what you want to have explained briefly and what more extensively. If you are not satisfied with the initial response, work iteratively to achieve the desired outcome.

Exercise

Repeat this process with your own program, one from the Internet or ask the LLM to generate one for you.

Please give me an example Python program for my current level. It should contain a function and an if-statement but no loops. Please do not add any explanation comments to it, as I want to use it to practice the interpretation of source code.

If the program is not corresponding the desired difficulty level, ask for something more difficult or easier, including or excluding particular concepts (e.g. conditional execution, loops).

Start from setting the context and follow the other steps of the example.

Reflection

Take a few minutes to reflect on this activity. If possible, exchange your observations with a peer – you may each have noticed different things.

Adaptations: Did this activity need anything from your tutor role prompt (Setup) that you hadn’t anticipated – a new instruction, more context, a different structure?
Spot the 4D: Which of Delegation, Description, Discernment, Diligence – and which specific part of it – did this activity mainly exercise? Where do you see a loop (Delegation-Diligence or Description-Discernment) at work?
This activity: Which did you choose in Semantics – Novice or Advanced – and why? How did that choice change how much you delegated to the LLM?

Error Interpretation

Overview

At times, a program may fail to run due to syntax errors, which are mistakes in the structure of the code. Other issues may also prevent it from executing properly. When such errors occur, the computer generates a “traceback”. This is a report that details where the errors happened in the code. For beginners, interpreting a traceback can be challenging, but learning to recognize and understand common error messages is crucial. Developing this skill will significantly accelerate your ability to troubleshoot issues and enhance your overall programming efficiency.

Context (code + error)

This is a modified code, where an error was introduced. You may pass it to an LLM together with the traceback message or not.

text = [
  "It is easier to fix the problem with a program which is not working at all",
  "then to identify and fix a problem with a program which is working but incorrectly."
]


for line in text:
    words = line.split()
    for word in words:
        counts[word] = counts.get(word, 0) + 1

bigcount = None
bigword = None

for word, count in list(counts.items()):
    if bigcount is None or count > bigcount:
        bigword = word
        bigcount = count

print(bigword, bigcount)

Let us assume that we used obtained the following traceback:

Traceback (most recent call last):
  File "/home/joanna/usr/space/tmp/demo.py", line 10, in <module>
    counts[word] = counts.get(word, 0) + 1
NameError: name 'counts' is not defined

1: Structure

As with the code, we will start from the abstract understanding going down to the details. We may continue in the same chat session (if the error is related to the code) or start a new one (otherwise).

As my personal tutor, please help me understand a traceback (ERROR) I got while executing a program (CODE).

This is the CODE:

text = [
  "It is easier to fix the problem with a program which is not working at all",
  "then to identify and fix a problem with a program which is working but incorrectly."
]


for line in text:
    words = line.split()
    for word in words:
        counts[word] = counts.get(word, 0) + 1

bigcount = None
bigword = None

for word, count in list(counts.items()):
    if bigcount is None or count > bigcount:
        bigword = word
        bigcount = count

print(bigword, bigcount)

Here is the ERROR:

Traceback (most recent call last):
  File "/home/joanna/usr/space/tmp/demo.py", line 10, in <module>
    counts[word] = counts.get(word, 0) + 1
NameError: name 'counts' is not defined

Please provide explanations at my current level. During our conversation, please act as my tutor without providing explanations or solutions until I explicitly ask you for them.

Now, I would like to know how I should approach interpreting tracebacks in general. What I need to pay attention to in order to understand what caused a problem while executing a program. First, provide generic guidelines without referring to ERROR. Keep it short! List the top level steps. And explain more in an interactive mode. Later, we will analyze the actual ERROR.

2: Interpretation

After reading the suggested steps, we may try to interpret the traceback.

I understand the interpretation schema. Please lead me through this process of interpreting ERROR by asking questions in the suggested order. Please ask just one question at a time and wait for my response.

You can now go interactively with answering questions, asking for hints or answers. The LLM will by default offer you an explanation or solution, so you need to prevent it when asking just for a hint.

I do not have an idea. Could you give me a hint? Please do not answer the question, but just help me to find an answer on my own.

Alternatively, if it is too difficult for you, ask for a complete interpretation of the traceback and try the iterative process on another example.

Could you give me a traceback and practice with me interpreting it?

Practice till you achieve a desired fluency in interpreting error messages.

3: Fixing

Now, we may try to fix the problem. If it in the program we provided, we may start just straightforward, but if we asked for an example traceback, we may ask for corresponding code.

Could you give me an example code which could cause the error we just interpreted before we start fixing the problem? Please do not provide information on how to fix the problem. I want to do it on my own with your suggestions.

Next, you can go iteratively, answering questions, asking for hints or answers.

Ask for more examples and practice till you achieve the desired learning effect.

Exercise

Repeat this process with your own program, one from the Internet or ask the LLM to generate one for you. Introduce a modification to the program so it stops working. Alternatively, ask the LLM to generate a program with an error and a corresponding traceback.

Reflection

Take a few minutes to reflect on this activity. If possible, exchange your observations with a peer – you may each have noticed different things.

Adaptations: Did this activity need anything from your tutor role prompt (Setup) that you hadn’t anticipated – a new instruction, more context, a different structure?
Spot the 4D: Which of Delegation, Description, Discernment, Diligence – and which specific part of it – did this activity mainly exercise? Where do you see a loop (Delegation-Diligence or Description-Discernment) at work?
This activity: In 2: Interpretation, you had to actively stop the LLM from just handing you the answer. What did you have to say or do to keep it in hint-mode?

Identifying Bugs

Overview

It’s generally easier to fix a program that isn’t working at all than to diagnose and resolve issues in a program that is functioning incorrectly. Pinpointing exactly what’s wrong in a program that partially works can be more complex because the errors are less obvious. Developing the ability to effectively identify and addressing these subtler issues is a crucial skill in programming. However, mastering this skill requires patience and time, as it involves a deep understanding of how the program is supposed to function and where it may be going wrong.

Context (code)

Let us introduce a mistake to a simplified version of the previous program by changing the comparison operator in the logical expression of the if statement. Instead of count > bigcount, we will use count < bigcount.

text = [
  "It is easier to fix the problem with a program which is not working at all",
  "then to identify and fix a problem with a program which is working but incorrectly."
]

counts = dict()

for line in text:
    words = line.split()
    for word in words:
        counts[word] = counts.get(word, 0) + 1

bigcount = None
bigword = None

for word, count in list(counts.items()):
    if bigcount is None or count < bigcount:
        bigword = word
        bigcount = count

print(bigword, bigcount)

1: Reporting a problem

If we want to get a support in fixing bugs in our program from human or an LLM, we must specify what is the problem that we are facing. In our scenario, we may ask the LLM what is needed to report a problem.

As my personal tutor, please help me understand the problem I encountered by providing explanations at my current understanding level.

Here is CODE:

text = [
  "It is easier to fix the problem with a program which is not working at all",
  "then to identify and fix a problem with a program which is working but incorrectly."
]

counts = dict()

for line in text:
    words = line.split()
    for word in words:
        counts[word] = counts.get(word, 0) + 1

bigcount = None
bigword = None

for word, count in list(counts.items()):
    if bigcount is None or count < bigcount:
        bigword = word
        bigcount = count

print(bigword, bigcount)

My program is not working as I expected. Please let me know what kind of information I should provide so someone can help me solve the problem with CODE.

First, do not explain the actual problem, give me information about required information.

For simple programs and our scenario, we may just focus on expected and actual behavior.

2: Fixing the problem

Now, we want the LLM to guide us to solve a problem.

I expected to get the most frequent word, but I got another word. Please give me a hint of what I should inspect to identify the source of the problem. I want to find out on my own, therefore, please do not provide any solution.

Once you get a hint, you may answer or ask for more details.

Could you cite the if-statement you are referring to and provide a more detailed hint?

You may continue till you solve the problem. However, in this example it is obvious as we introduced it ourselves. Moreover, if there is meaningful naming of variables in a program, it would be possible for the LLM to identify and fix the issue without any further details.

Experiment

We may experiment to see how naming of variables will impact bug fixing by the LLM. Now, try the same in a new chat, but with bigcount renamed to the_count and bigword to the_word.

My program is not working correctly. Please help me to fix it.

text = [
  "It is easier to fix the problem with a program which is not working at all",
  "then to identify and fix a problem with a program which is working but incorrectly."
]

counts = dict()

for line in text:
    words = line.split()
    for word in words:
        counts[word] = counts.get(word, 0) + 1

the_count = None
the_word = None

for word, count in list(counts.items()):
    if the_count is None or count < the_count:
        the_word = word
        the_count = count

print(the_word, the_count)

What is your conclusion?

Exercise

A basic task: Repeat this process with your own program, one from the Internet or ask the LLM to generate one for you. Introduce a modification to the program so it still works, but incorrectly. You may change logical expressions or calculations.
An advanced task: Repeat this process on a program that you really want to debug.
A reversed task: Ask an LLM to generate a program with errors or bugs and try fix it.

Reflection

Take a few minutes to reflect on this activity. If possible, exchange your observations with a peer – you may each have noticed different things.

Adaptations: Did this activity need anything from your tutor role prompt (Setup) that you hadn’t anticipated – a new instruction, more context, a different structure?
Spot the 4D: Which of Delegation, Description, Discernment, Diligence – and which specific part of it – did this activity mainly exercise? Where do you see a loop (Delegation-Diligence or Description-Discernment) at work?
This activity: The naming experiment (bigcount/bigword vs. the_count/the_word) changed how well the LLM found the bug without further hints from you. What does that reveal about how it was actually reasoning, versus what it looked like from outside?

Solving Tasks

Overview

While using an LLM to generate solutions can be convenient, it doesn’t contribute to improving your programming skills. True learning in programming comes from hands-on practice. If you’re aiming to become proficient, it’s essential to actively engage in writing programs yourself. This direct experience is key to understanding programming concepts deeply and developing the ability to solve problems independently.

Platform Awareness Hint: For guidance and feedback on Artemis tasks, try Iris as a context-aware, built-in assistant.

Context (task)

Let us a task from 198801 and the Python for Everbody textbook. To make it more complex, we merged two tasks into one: Chapter 3, Exercise 3; and Chapter 4, Exercise 7.

Write a program to prompt for a score between 0.0 and 1.0. If the score is out of range, print an error message. If the score is between 0.0 and 1.0, call a function determining a grade using the following table:

Score	Grade
>= 0.9	A
>= 0.8	B
>= 0.7	C
>= 0.6	D
< 0.6	F

The function should be named compute_grade and take a score as its parameter and return a grade as a string. The program should not contain any user interaction, just the function.

1: Guidance

As in the previous examples, we will set the context for our conversation first. After setting the context, you may start a conversation with the LLM. It may tend to provide you corrected version of your solutions, therefore you may need to remind the LLM about the tutoring rules from time to time.

As my personal tutor, please help me solve a task. I want to program it myself but I need hints that will help me to start. I am a novice programmer in Python, so guide me in small steps giving me just one hint at a time. Your hints should refer just to one statement needed to accomplish the next step towards a complete solution. Please let me find the answers in the task description rather than instructing me what to write in Python. I will respond with Python code expecting you to give me feedback.

If my solution is incorrect or incomplete, give me hints that will help me to fix the problem myself. Provide me with a bug fixed or improved version only if I explicitly ask you for it, otherwise just hints without any code.

In my questions, I will refer to the given task as TASK.

Here is TASK:

Write a program to prompt for a score between 0.0 and 1.0. If the score is out of range, print an error message. If the score is between 0.0 and 1.0, call a function determining a grade using the following table:

Score	Grade
>= 0.9	A
>= 0.8	B
>= 0.7	C
>= 0.6	D
< 0.6	F

The function should be named compute_grade and take a score as its parameter and return a grade as a string. The program should not contain any user interaction, just the function.

2: Practice

When you complete the task, you may ask for another one to practice the same concepts. Depending on how easy the original task was for you, you may ask for a task at a different difficulty level (simpler/similar/harder). You may express wishes related to the syntax of the new task or domain.

An example, prompt could be this:

Now, I understand how to solve a TASK, but I would like to practice more. Please give me a similar task with the same data types and control flow statements. It should be slightly more difficult than TASK but with a lower number of cases in the if-statement. Generate a solution, but do not present it to me, just check if it is possible to solve the new task with the concepts I learned. I am studying physics and like mountain biking, so please provide something related to my interests.

If the generated task is not appealing, try to regenerate the response or modify your prompt.

If you want to learn only particular concept, e.g. logical expressions, you may also ask an LLM to generate a program when you need to fill gaps, e.g. expressions in if-statements.

3: Feedback

For your own solutions, you can ask an LLM to provide you feedback to improve your programming skills and style. You will have to provide the TASK and your SOLUTION.

I’ve completed a programming TASK and want to improve my SOLUTION. Please review it step by step, focusing on one issue at a time, starting with the most critical. For each issue, include:

Category (efficiency/flexibility/usability/readability/maintainability/testability/correctness/security)

Severity (high/medium/low)

What & why (brief, with evidence)

Do not provide any fixes, but give me hints and let me find out how to improve my SOLUTION.

Exercise

A basic task: Take any task you wish and repeat the proposed process. Continue till you achieve the desired learning effect.
A reversed task: Ask an LLM to generate a task for you.

Reflection

Take a few minutes to reflect on this activity. If possible, exchange your observations with a peer – you may each have noticed different things.

Adaptations: Did this activity need anything from your tutor role prompt (Setup) that you hadn’t anticipated – a new instruction, more context, a different structure?
Spot the 4D: Which of Delegation, Description, Discernment, Diligence – and which specific part of it – did this activity mainly exercise? Where do you see a loop (Delegation-Diligence or Description-Discernment) at work?
This activity: When you asked for feedback on your SOLUTION (3: Feedback), which category or severity of issue surprised you most? Would you have caught it yourself without the LLM?

Getting Help

Overview

The official documentation is the most reliable source of information about a programming language. However, beginners might find the technical descriptions in these documents challenging to understand. In such cases, using an LLM can be beneficial. It can help you interpret the documentation and provide guidance on how to apply what you’ve learned. This approach allows you to gradually build your understanding while ensuring you have access to accurate and up-to-date information.

If you use an LLM to get information about the newest functions or packages, it is good to be aware of the cutoff date of a particular LLM. Without the Internet search, it can only provide information about the versions that were available when the LLM was trained. The workaround is to ask the LLM to search for newest versions/options in the Internet.

1: Usage examples

If you know a function name, you may ask about its documentation and example usage.

Please help me to understand how the print() function works in Python. Please give a description and a few (2-3) usage scenarios suitable for my level. Please keep your response short, but propose a few directions I could explore and wait for my decision to provide more details or examples for them.

Similarly, you may ask about a package.

I want to use the math package from Python. Please help me to learn about it. Please give a description and a few (2-3) most used functions with their short (1 sentence) explanation to comprehend at my current level.
Please keep your response short, but suggest what else would be useful to learn about this package and wait for my decision to provide more details.

2: Reading documentation

Reading technical documentation is a desired skill, as it is a reliable source of information providing precise and relevant descriptions. You may use an LLM to help you in learning how to interpret it.

I want to learn how to read technical documentation for Python. Please give me a docstring of one of the most frequently used functions in Python. Tutor me how to read it by giving me hints. Explain how to interpret pieces of information step by step. Next, ask me to interpret something; evaluate my response and give me hints if I got it wrong. Continue with next pieces of information till we finish interpreting the whole example.

3: Apropos

Sometimes, you remember that there is a function or a package that you could use for your task, but can not recall its name. In R, there is apropos() function, that searches over the documentation and provides related functions. We may use an LLM to get similar results.

I would like to get a random integer. What function could I use for it in Python?

4: Brainstorming

You may also ask an LLM to give you advice on what to use in a particular situation.

I would like to store and process data from a small excel file. My program will be executed on a slow computer with limited memory. Which Python package would you recommend to use and why? Please keep your answer short and clear for my current level. Do not give any example usage yet.

However, brainstorming for a real project works the best with an LLM-based coding assistant.

Exercise

A basic task: Pick a function from this course that you have used but never actually looked up. Repeat the Usage examples workflow (1) on it yourself.
An advanced task: Repeat the Reading documentation workflow (2) on a function you will actually need for an upcoming assignment or your own project, not a demo one. Read the real documentation with the LLM’s help, not a simplified version.

Reflection

Take a few minutes to reflect on this activity. If possible, exchange your observations with a peer – you may each have noticed different things.

Adaptations: Did this activity need anything from your tutor role prompt (Setup) that you hadn’t anticipated – a new instruction, more context, a different structure?
Spot the 4D: Which of Delegation, Description, Discernment, Diligence – and which specific part of it – did this activity mainly exercise? Where do you see a loop (Delegation-Diligence or Description-Discernment) at work?
This activity: Getting Help involves more automation than Solving Tasks – you are not asked to work through hints here. Why is it acceptable to delegate more in this activity (Delegation: problem awareness) than when writing your own solutions?

Disclosure [Transparency diligence]: The Reflection tabs and the restructuring of this page were developed through an iterative collaboration between the instructor and Claude (Anthropic). The instructor set the direction and structure – including which content to keep, move, or trim – and made the final decisions on wording, scope, and content at every step. Claude drafted specific phrasing, exercises, and reflection questions, and proofread the text. Both contributed edits across several rounds of review.

Unlocking the Tutoring Powers: Practice

Joanna Chimiak-Opoka

2026-09-11

Goal

Terminology

Overview

1: Explanation

2: Rephrasing

3: Examples

4: Differentiation

5: Quiz

Exercise

Reflection

Code Interpretation

Overview

Context (code)

1: Purpose

2: Visualization

Prompt

Output

Example visualization

Workaround hint

3: Semantics

Novice

Advanced

4: Comments

Exercise

Reflection

Error Interpretation

Overview

Context (code + error)

1: Structure

2: Interpretation

3: Fixing

Exercise

Reflection

Identifying Bugs

Overview

Context (code)

1: Reporting a problem

2: Fixing the problem

Experiment

Exercise

Reflection

Solving Tasks

Overview

Context (task)

1: Guidance

2: Practice

3: Feedback

Exercise

Reflection

Getting Help

Overview

1: Usage examples

2: Reading documentation

3: Apropos

4: Brainstorming

Exercise

Reflection