Coding with ChatGPT

Start with a precise description

The quality of the code you get depends heavily on the quality of the description you give. Vague requests produce generic code. A useful request names the language, the input, the expected output, and any constraints, such as not using a particular library or keeping the function short. If the task involves data, describe the shape of that data: what fields exist, what types they are, and what a typical example looks like.

Break large tasks into small pieces. Ask for one function at a time, check it, and then ask for the next piece. This keeps each answer short enough to review properly and makes it obvious where a mistake came from if something does not work. It also mirrors how good software is built in the first place: small, testable units assembled into something larger.

Write a Python function called clean_price that takes a string like "$1,299.00" or "1299" and returns the price as a float. It should handle commas, a leading dollar sign, and empty strings by returning 0.0. Include a short docstring and three example calls.

When the answer arrives, read it before running it. Check that the function names match what you asked for, that edge cases are handled, and that nothing surprising is happening, such as reading files or making network requests you did not ask for. Running code you have not read is how small mistakes become large problems.

Use ChatGPT to explain code you did not write

One of the most practical uses of a coding assistant is reading code written by someone else, or by yourself six months ago. Paste a function and ask for a line-by-line explanation in plain language, or ask what the code does at a high level and where its weak points are. This is often faster than tracing through logic by hand, especially in an unfamiliar codebase.

Ask follow-up questions when the first explanation is too general. Ask what a specific variable holds at a particular point, why a certain condition exists, or what would break if an input were empty. A good explanation should let you predict the code's behaviour on a new input. If you still cannot predict it, keep asking until you can.

This approach also works for error messages. Paste the full error, the code that produced it, and what you expected to happen. The error text alone is often not enough, because the same message can come from several causes. The surrounding code and a description of the intended behaviour narrow the problem down to something answerable.

Debug in a loop, one change at a time

Debugging with ChatGPT works best as a loop. First, describe the symptom precisely: what you ran, what happened, and what you expected. Then try the suggested fix, run the code again, and report the new result, even if it is a different error. Each round of feedback gives the assistant better information, and it also builds your own record of what has already been tried.

Change one thing at a time. If you apply three suggested fixes at once and the problem disappears, you will not know which one mattered, and you may have introduced a new issue you will only discover later. If a suggestion does not work, say so plainly and paste the new error rather than starting a fresh conversation, because the history of failed attempts is useful context.

Refactor and test, but verify everything

Refactoring is a strong use case because the goal is clear: the behaviour must stay the same while the code gets clearer. Ask ChatGPT to simplify a function, split a long function into smaller ones, or rename variables for clarity, and then run your existing tests to confirm nothing changed. If you have no tests, write a few simple checks first, before the refactor, so you have something to compare against.

Asking for tests is equally practical. Give ChatGPT a function and ask for test cases covering normal inputs, empty inputs, and boundary values. Review the tests as carefully as the code: a test that checks the wrong expectation will pass while the code is wrong. Tests are only useful if you understand what each one asserts.

Never assume generated code is correct, secure, or complete. Check it against your project's requirements, run it, and review anything that touches passwords, payments, user data, or file deletion with extra care. ChatGPT can produce code that looks confident and still contains a subtle bug, an outdated library call, or a security weakness. The final check is always yours.

Learn a new language or library faster

When you are learning, ask for small worked examples rather than long lectures. Pick one concept, such as list comprehensions, error handling, or fetching data from an API, and ask for a short example with an explanation of each part. Then change the example yourself and see what happens. That cycle of example, experiment, and question builds understanding faster than reading alone.

Ask ChatGPT to compare approaches when you are unsure which one fits. For example, ask when to use a loop versus a built-in function, or what the trade-offs are between two ways of storing data. These comparisons help you build judgement, not just syntax knowledge, and judgement is what separates someone who can copy code from someone who can write it.

Finally, keep notes on patterns that recur in your own work. If you ask for the same kind of script repeatedly, save a good prompt and a good answer as a starting template. Over time you build a personal library of starting points, and ChatGPT becomes a tool for adapting them to new problems rather than a blank page every time.

Frequently asked questions