How to Learn to Code with ChatGPT Without Skipping Practice

Ask ChatGPT to write a JavaScript function that returns the longest word in a sentence and you get one, immediately, working. Ask it for a single hint and tell it to wait, and it gives you the hint and stops. Same tool, same exercise, one afternoon apart. The only thing that changed was the wording.

All three exchanges below were captured on 8 September 2026 in ChatGPT while signed out, so every one of them can be reproduced without an account, a subscription, or anything to install. What follows is the finished-code run, the run that waits, what came back when a deliberately broken attempt was handed over, and the four-step loop that holds the whole thing together.

What Happens When You Just Ask for the Code

Asking ChatGPT for a function returns a complete, working one on the first try, which ends the exercise before any practice happens.

Here is the version almost everyone types first.

Write a JavaScript function that returns the longest word in a sentence

ChatGPT, signed out, 8 September 2026.

Back came a complete solution: split the sentence into words, then use reduce to keep whichever word is longest. A console.log example arrived with it, and one closing line explaining what the code does.

Nothing is wrong with any of that. The code runs. It is also the entire exercise, finished, in the time it took to type one sentence. The learner wrote nothing.

Notice what the reply does not contain. No next step. No check on whether the reader followed it. No reason to open an editor. The transaction is complete, and the only thing that happened is that a problem stopped existing.

This article does not reproduce that function. Printing it here would do to you exactly what the screenshot did to the learner in it.

One exchange, on one day, captured without an account. It shows what happened, not what happens every time.

Why Finished Code Costs You Later

Copied code raises today's output and lowers tomorrow's, because the practice that builds the skill is the part the tool removed.

The clearest evidence comes from a randomized trial with nearly 1,000 high school maths students, published in PNAS. Two interfaces were tested against a control group: a plain chat window, and a tutor version built with guardrails. While students had access, both raised grades sharply, the plain chat by 48% and the guardrailed tutor by 127%.

Then the researchers took the access away and ran an exam. The plain-chat group scored 17% below students who had never used the tool at all. The guardrailed group came out level with the control. The paper's own abstract names the mechanism:

Without guardrails, students attempt to use GPT-4 as a "crutch" during practice problem sessions, and subsequently perform worse on their own.

The detail that makes this usable is what the guardrail actually was. Not a different model, and not a paid product. The tutor version gave hints instead of answers, and had the worked solutions on hand so it could steer without surrendering them. That is a difference in wording, which means you can build it yourself in an ordinary chat window. Where AI tutoring helps and where it fails is covered separately in what AI tutors do well and where they fail.

There is a second, more immediate reason to keep your hands on the keyboard. In the Stack Overflow 2025 Developer Survey, 45.2% of developers said debugging AI-generated code takes more time, and only 3.1% said they highly trust the accuracy of AI output. Code you did not write is code you cannot debug.

The Prompt That Makes ChatGPT Wait

Three clauses turn a code generator into something that stops and waits for you.

I'm learning JavaScript. Don't write the function for me. Give me one hint
for how to find the longest word in a sentence, then wait for my attempt

ChatGPT, signed out, 8 September 2026.

What came back was one hint: split the sentence into individual words, then keep track of the longest word seen while going through them. Then it stopped, with an offer to "show me your attempt, and I'll give feedback without writing the function for you."

That is the whole intervention. No settings, no custom instructions, no account.

Each clause is doing a specific job, and the one readers drop is usually the last:

That last row is the one that matters. A model told not to write the function will frequently write it anyway a paragraph later, framed as an illustration. The explicit wait is what closes that door, and it has to be restated whenever the thread drifts.

Get It Wrong on Purpose

Most guides on this topic stop at the previous section. Here is the part they skip: what the tool does when your attempt is broken.

The attempt handed over in the same thread was wrong on purpose.

function longest(s) { return s.split(" ").sort((a,b) => a.length - b.length)[0]; }

It sorts the words from shortest to longest, then takes index [0]. So it returns the shortest word in the sentence, confidently, with no error.

ChatGPT, signed out, 8 September 2026.

The reply did three things, in this order:

• Credited what was right. It named .split() and the comparison on .length as correct.
• Located the fault without naming the fix. It asked which end of the array contains the longest word after sorting from shortest to longest. That is a real diagnosis, delivered as something the learner has to answer: the bug is now pinned to one expression, the reader still has to do the pinning, and the parts of the file that work are untouched.
• Scoped the repair. "Try fixing just that part." Not a rewrite, not a better approach, not a lecture on reduce.

That is a Socratic correction: the fault is located, the correction is handed back. It is also the same guardrail the PNAS trial tested, produced here by nothing more than a sentence of instruction in a free, signed-out chat.

The fix is one word. It is the position in the sorted array, and this article is not going to name it, for the same reason it did not print the finished function earlier.

The caveat belongs here rather than in a footnote: this was a single exchange on a single attempt. It shows what a Socratic correction looks like when you get one. It is not a promise that every wrong attempt gets the same treatment.

The Four-Step Practice Loop

Those three screenshots trace a loop you can run on any exercise, in any language.

1. Ask for one hint and an explicit wait. Never for the function. Restate the constraint if the thread drifts.
2. Write the attempt yourself, in an editor, and run it. Get an error or a wrong output before showing it to anyone. The attempt is the practice; everything else is scaffolding around it.
3. Paste the attempt and ask for feedback that names the fault without fixing it. You want the location of the bug, not a corrected file.
4. Once it works, ask it to explain your code back to you, line by line, and correct your reading. This is the step people skip, and it is the one that turns a fixed bug into something you know.

Step four deserves the emphasis. The explanation has to be of your code, not of a canonical solution, because the gap you need closed is between what you wrote and what you thought you wrote.

The loop needs exercises to run on, and the pool matters more than the tool does. Coding practice platforms supply the small, checkable problems this works best on. When those stop stretching you, beginner project ideas are where the loop moves next.

What a Chat Window Cannot Give You

A chat answers what you ask, which means anything you have never heard of stays invisible to you.

That is a structural limit, not a flaw in the model. There is no sequence, no curriculum, and no record of what you have not covered. The loop above fixes the practice problem and leaves the coverage problem untouched. You can run it well for three months and still not know that array methods, scope or the DOM were things you were meant to meet.

That gap is what a course is for. Scrimba's free Learn to Code with AI treats this subject as its actual curriculum rather than a side effect: a beginner course in HTML, CSS and JavaScript where prompting effectively for code generation and debugging with AI assistance are things you are taught, alongside building the projects. It is free.

If you want the language rather than the AI angle, Scrimba's free Learn JavaScript course covers variables, functions, arrays, objects and DOM manipulation, which is the ground the exercise in this article sits on. For the wider route through the language, the complete beginner's guide to learning JavaScript maps the order to work through.

Neither replaces the loop. Structured lessons give you the map. The loop is what stops you reading the map instead of walking it.

Where This Approach Falls Down

Four limits, because the routine is easier to describe than to keep:

• The discipline is yours, not the tool's. The stopping instruction holds only while you keep restating it. It drops the moment you ask for the answer, and asking is always one keystroke away at eleven at night.
• ChatGPT can be confidently wrong about your code. That is why step four asks it to explain what you wrote rather than trusting what it wrote. Check any surprising claim against the language documentation before you build on it.
• One exercise is not a curriculum. These runs show the wording works on a beginner array problem, and nothing beyond that.
• Nothing here was captured with an account. No claim is made about what a paid plan, a different interface or a different model would do, because none of that was tested.

For a broader view of which tools and courses fit which kind of learner, this roundup of AI tools and courses for learning to code covers the landscape this page deliberately does not.

Frequently Asked Questions

Can you actually learn to code with ChatGPT?

Yes, if you write the code yourself. Used as a hint machine and a reviewer, it works. Used as a source of finished functions, the evidence points the other way: students with unrestricted access scored 17% below a control group once the tool was taken away.

What should you type so ChatGPT does not write the code for you?

Four clauses: say you are learning, forbid the finished function, ask for one hint, and tell it to wait for your attempt. The wait is the part people leave out, and without it the reply often supplies the function anyway as an example.

Does using ChatGPT while learning to code make you worse at it?

Unrestricted use during practice can. In a randomized trial with nearly 1,000 students, the group using a plain chat interface performed 17% worse on an unaided exam than students who never had access. A version that gave hints instead of answers showed no such drop.

How do you get ChatGPT to check your code without fixing it?

Paste your attempt and ask it to tell you what is wrong without correcting it. In the run recorded here, that produced a returned prompt about which end of a sorted array held the longest word, plus an instruction to fix only that part.

Is there a free course for learning to code with ChatGPT?

Yes. Scrimba's Learn to Code with AI is free and built for complete beginners, covering HTML, CSS and JavaScript while teaching how to prompt for code generation and debug with AI assistance as part of the curriculum.

Key Takeaways

• The same tool hands over finished code or coaches you through writing it. The variable is the wording of your prompt, not the model or the plan.
• The stopping instruction is the load-bearing clause. "Then wait for my attempt" is what prevents an answer arriving dressed as an example.
• In a randomized trial of nearly 1,000 students, plain chat access raised practice grades and then cost the group 17% on an unaided exam. Hints instead of answers removed the effect.
• A wrong attempt is worth more than a right one, because it is what produces a correction you have to act on yourself.
• Ask for an explanation of your own code, not of a model solution. The gap worth closing is between what you wrote and what you thought you wrote.
• A chat window has no curriculum, so it cannot tell you what you have never covered. That is what a structured course is for.

Sources

• Bastani, Hamsa, et al. "Generative AI without guardrails can harm learning: Evidence from high school mathematics." PNAS 122(26), 1 July 2025. https://www.pnas.org/doi/10.1073/pnas.2422633122
• Stack Overflow. "2025 Developer Survey, AI section." 2025. https://survey.stackoverflow.co/2025/ai/
• Screenshots: three exchanges captured in ChatGPT while signed out, 8 September 2026. No model name is shown in the interface, and each is a single run.