Make One Useful Code Change

A small program almost does what you want. Its reminder sounds wrong, its note format needs tidying, or its default planning interval doesn't suit you. Instead of accepting the irritation, you can change it.

Choose a small existing program or something in your own project. Run it, read the part that matters, make one useful edit, and restore the original. By the end, you should be able to explain your change without asking the assistant again.

1. Structure — choose your small win

Finish this sentence: “When I use this program, I want ___ instead of ___.” Perhaps you want a clearer reminder or a checklist item you can paste into your notes.

Pick something you can already run, with an effect you can see immediately. Use its existing run instructions. If you have no starting code, use the optional example below; your own project is equally welcome.

Locate the file controlling the behaviour. Before editing, duplicate it with a clear backup name, such as note-before.py. Keep that copy untouched. For a small multi-file project, copy its folder instead. Source backups do not restore other files, so try file-writing programs on copies of your material.

Optional starting point: a pocket note formatter

This Python program turns a short note into a tidy bullet you can copy elsewhere. Save it as plain text named note.py, not note.py.txt, preserving the indentation:

def format_note(text):
    text = text.strip()
    if not text:
        return "Please enter a note."
    return f"- {text}"


note = input("Your note: ")
print(format_note(note))

It uses only built-in Python features: no packages, accounts, or network connection. It displays text without saving or overwriting your notes.

With Python 3 already installed, open a terminal in the folder containing note.py. You can use cd "path to your folder" to reach it. Then run:

• Windows: py note.py if your installation provides py; otherwise use python note.py if that is your installed Python 3 command.
• macOS or Linux: python3 note.py.

Enter commands at the terminal prompt; use quit() to leave Python's >>> prompt first. If the command is unavailable, use your installation's known Python 3 command or an already-running project for this lesson.

Type Pack headphones and press Enter. The expected output is - Pack headphones. Now make your backup, before changing the code.

2. Understand — follow the short path

Input is what a program receives; output is what it produces. Here, the input is your typed note and the output is a line in the terminal.

A variable is a name referring to a value. note holds the text you entered. A function is a named piece of work: format_note receives text and returns the formatted result. print displays that result.

Read the function from top to bottom. strip() removes whitespace from the ends, preserving the words inside. if not text catches an empty or spaces-only note and returns a readable message. Otherwise, the final return adds a bullet. The f before the quoted string lets {text} insert the value into it. Indentation groups the function's instructions.

In your program, where does input arrive, which variable carries it, and which line makes the output? Ask OpenCode to explain unfamiliar expressions using your actual input.

3. Choose LLMs, Agents, skills, tools — one helper, one job

Use OpenCode with a coding-capable model you already have. The model interprets your request; the agent works with project files and tools. Use your editor and existing run command. Add a specialised skill only if your project needs it.

Keep passwords and private material out of the request. Replace the bracketed details and send:

I'm making one change to my own small program.
File: [file path]. Run command: [existing command].
Current behaviour: [what happens now].
Wanted behaviour: [one specific difference].

Read the relevant code and explain the input, output, variables,
and function involved in plain English. Explain the relevant lines,
then make only this change without rewriting the project.
Preserve existing input checks and unrelated behaviour. Add no
dependencies. Leave my backup [path] untouched. Show the changed
lines and tell me how to run it and restore the backup.
Only report execution if you actually ran it.

For the example, request a Markdown checklist item instead of a bullet: - [ ] Pack headphones. Paste it into a checklist-capable notes app, or use it as plain text.

4. Build — change, try, undo

Inspect the edit. In the example, the final return becomes:

    return f"- [ ] {text}"

Only the prefix changes. Input handling and the blank-note message still matter. In your project, keep keyboard operation, readable labels, and existing validation working through your edit.

Save and run again. Try Pack headphones, then run once more with only spaces. Expect the checklist item first and Please enter a note. second. For your own program, choose one ordinary input and one useful edge case related to the change. If it fails, give OpenCode the exact error or unexpected output and the input that produced it.

Actually undo it: open note-before.py, copy its contents over note.py, and save. Run note.py again: Pack headphones should produce the original bullet. Restore your own file from its backup in the same way. You now know the way back; reapply the useful edit if you want to keep it.

Choose one personal next improvement, such as a heading you regularly type. Explaining, using, and reversing your change is the L1 outcome. When teammates will rely on the result, continue with T08-L02: Code without being a developer (opens in a new tab). Shared or production software brings responsibilities beyond this own-work exercise.

Sources

Official Python documentation fetched on 2026-09-09: running scripts (opens in a new tab), input and print (opens in a new tab), and defining functions (opens in a new tab).