Most students who "learn to code" never finish an app. They finish tutorials: watch a video, copy the code, and the project dies in a folder called
final_final_v2 the moment the video ends. An AI coding assistant changes that — but only if you build something real, small, and deployed. This article is the full path: one small app, a study tracker, from a blank page to a live link you can send to a friend, built entirely on free tiers, with the limits you will actually hit and the honesty rules that keep it acceptable as coursework. By the end you will have a working app at a public link, a GitHub repository with your own commits, and the ability to explain every file in it. That last one matters most: an app you cannot explain is not your project — it is a demo someone else built for you.
Before you prompt: the 15-minute plan
Every failed first app fails the same way: it starts too big. "A social network for students with chat, events, and a marketplace" is not a first app. It is five apps wearing a trench coat. The AI will happily generate all five, badly, and you will spend your weekend debugging code you do not understand.
Pick one problem you actually have. Ours: you want to know how much you really study. A study tracker with exactly three features:
- Log a study session (subject, minutes, date).
- See totals per subject for the week.
- See your current streak of days studied.
That is it — no accounts, no social feed, no dark mode. Three features is a weekend; ten is a graveyard. Write the three features down in one paragraph before you open any tool: that paragraph becomes your spec, and the spec is what the AI builds from. If you cannot describe the app in five sentences, you do not understand it well enough to build it yet.
If you have never written Python, do that first: our 30-day Python plan gets you to the point where you can read the code the AI writes and spot when it is wrong. You do not need to be good at Python to build this app. You need to be able to read it. There is a difference, and it is the whole game.
Your free toolkit
You need exactly two things: somewhere the AI writes the code, and somewhere the app runs. Both are free for students, with limits you should know before you start.
| Tool | What it does | Free tier, verified 11 Nov 2026 | Best for |
|---|---|---|---|
| Replit Starter | AI agent builds and runs the app in the browser; nothing to install | $0; daily Agent credits up to an unpublished monthly cap; Lite build only; 1 published app, down after 30 days; "Made with Replit" badge; 0 background tasks; 1 GiB database | Your first build, end to end, in one place |
| GitHub Copilot Free | Code completions and chat inside your editor (VS Code and others) | $0, no card required; 2,000 code completions a month; limited chat and agent allowance in AI credits; auto model selection only | Writing and fixing code in a real editor |
| GitHub Copilot Student | Same assistant, student plan via GitHub Education | Free for verified students; unlimited code completions; small AI-credits allowance for chat and agent; auto model selection only | The best free coding setup once you are verified |
The honest recommendation: start in Replit. Its agent turns a prompt into a running app in the browser, which is exactly what a first build needs — no setup, no terminal, no "it works on my machine." Read our full breakdown of Replit for students before you commit to it, because the free plan's limits shape what you can ship. Once the app exists, move the code into VS Code with GitHub Copilot for students for the fixing stage — Copilot is better at small, precise edits than at generating a whole app from nothing, and the Student plan's unlimited completions remove the one cap you would otherwise hit first.
Step 1: Write a spec the AI can actually build from
A bad prompt produces a bad app. "Build me a study app" gives you whatever the model imagines a study app is — probably a login page, a dashboard, and a database you did not ask for. A spec gives it decisions to follow. Write yours like this:
Build a study tracker web app in Python. One page. A form with three fields: subject (text), minutes (number), date (defaults to today). Below the form, a table of all logged sessions, newest first. Above the table, a summary: total minutes this week, and total minutes per subject. Store sessions in a simple file or database. No user accounts, no login. Keep the code in as few files as possible and add a short comment above each function explaining what it does.
Notice what the spec does: it names the language, every field, the exact behaviour, what to exclude, and how the code should be documented. Every sentence here saves ten minutes of debugging later. Keep it under 150 words — longer than that and you are designing, not specifying.
Step 2: Prompt the scaffold
Paste the spec into Replit Agent as your first and only prompt, then stop. The classic beginner mistake is prompt spam: asking for a chart, new colours, and a login all at once, then wondering why the app broke in a way nobody can trace.
When the scaffold is running, your job is to look at it, not to keep prompting. Click every button. Type nonsense into the form: 0 minutes, 10,000 minutes, a blank subject. An app that only works when used politely is not finished. List every bug you find, then fix them one at a time — the crash first, the ugly button last.
One more rule: read the file list before you read the code. A study tracker should be a handful of files — a main app file, a template, maybe a data file. If the AI created twelve files with names you do not recognise, ask it to explain the structure first. Understanding the shape of the project is a prerequisite for fixing it.
Step 3: Test like a user, not like a fan
You are not the app's biggest supporter — you are its harshest tester. Run this checklist before you show it to anyone:
- Does it load on your phone, not just your laptop?
- Does a session you log actually appear in the table after a refresh?
- Do the weekly totals change when you add a session from last week?
- What happens when you submit the form empty?
- What happens when two sessions have the same subject spelled differently ("Maths" vs "math")?
That last one is the kind of bug AI-generated apps love: it works, it looks fine, and the data is quietly wrong. The fix is small — normalise the subject to lowercase — but you only find it by testing like a sceptic.
Step 4: When the AI writes broken code
It will. Probably in the first hour. The difference between students who finish apps and students who quit is not talent — it is a debugging workflow. Here is the one that works:
- Read the error message first. It usually names the file and the line. Open that file, go to that line, and read the ten lines around it before you do anything else.
- Ask the AI to explain, not to fix. "Explain in two sentences what this error means" teaches you the cause; "Fix it" teaches you nothing and often creates a second bug.
- Change one thing at a time. Change three and you will never know which one fixed it.
- Commit after every fix that works. A Git commit is a save point: when the next fix breaks everything, you go back in one command.
- Never re-prompt the same broken request more than twice. If two attempts fail, the prompt is the problem, not the model: paste the error and the relevant code into a fresh prompt and ask for the smallest possible change. If that fails too, shrink the feature — a working app without a chart beats a broken app with one.
One warning: the AI sometimes "fixes" a bug by deleting the feature that had it. Check the app still does all three things after every fix — a quiet deletion is worse than a loud error.
Step 5: Deploy it — get the live link
An app on your laptop is a homework file. An app at a public link is a project. In Replit, publishing is one click: the app gets a public URL you can share. That is the whole point of this article, so do it even if the app is imperfect. Imperfect and live beats perfect and local.
Know the limits before you celebrate: on Replit Starter you get one published app, it goes down after 30 days, and it carries a "Made with Replit" badge. That is fine for a first project — 30 days is enough for a portfolio review or a seminar — but it is not a permanent home. When it expires, republish it (free, takes a minute) or move the finished code to a host without an expiry — GitHub Pages costs nothing for a simple front-end. Replit Core is $20 a month ($18 a month billed annually) if you ever outgrow Starter, but do not pay for a first app. Pay when the second app needs it.
After publishing, use the live link for a real week of studying. The moment you use your own app daily, you will find the five improvements that matter — and they will be your ideas, not the AI's.
The free-tier walls you will hit
Every free tier here has one wall, in the order you will meet them:
- Replit Agent credits. Starter gives daily Agent credits up to a monthly cap Replit does not publish. Big prompts and repeated "fix it" loops burn credits fastest — the fix is discipline: one clear prompt, then small edits.
- One published app, 30 days. Set a calendar reminder for day 25 to republish or migrate.
- The database is 1 GiB and there are no background tasks. A study tracker will never fill 1 GiB — but do not plan a feature that needs something running while you are away.
- Copilot Free's 2,000 completions a month. A heavy debugging week eats them fast; Copilot Student removes the cap entirely, so verify your student status early — the single highest-value free upgrade in this article.
- Copilot's chat and agent allowance. Both free plans meter chat and agent use in AI credits. Use completions for writing code and save chat for when you are genuinely stuck.
None of these walls should stop you. They should shape your plan: build small, fix in small steps, and verify your student status before you need the headroom.
Coursework honesty: the rules that keep this yours
If this app is coursework, the build method is part of the submission. Most EU universities allow AI assistance in coding assignments — but they require you to declare it, and they grade your understanding, not the AI's output. Three rules keep you safe:
Declare the AI assistance. Write it in the project README and the submission: which tools you used and what they did. One paragraph is enough. Hiding it is the only thing that reliably gets students in trouble.
Keep your own commits. Your Git history is the evidence you built this in stages: scaffold, test, fix, fix, deploy. An empty repo with one giant commit called "final" looks exactly like a pasted answer. Commit after every working fix, saying what changed and why.
Be able to explain every file. Before you submit, open each file and explain it out loud: what it does, why it exists, what would break if you deleted it. If you cannot explain a file, learn it or remove it. A lecturer's first question about an AI-assisted project is always "walk me through this file" — and it is a fair question.
The principle is simple: the AI is a tool, like a calculator. You may use a calculator in an exam — you may not submit its answer as your reasoning. Same here. Your contribution is the idea, the spec, the testing, the debugging decisions, and the final understanding. Make sure all five are genuinely yours.
Three apps to build next
Once the tracker is live, the same five steps build almost anything small. Three good second projects, in order of difficulty:
- A flashcard quiz app. Same data pattern as the tracker — add a card, quiz yourself, track your score.
- A flat-expenses splitter. Same form-and-table shape, with one new idea: totals per person.
- A revision timetable generator. You type in exam dates and subjects; it outputs a plan. This one needs real logic, not just forms — a proper step up.
Build them in that order. Each one reuses the last one's skills and adds exactly one new idea.
Frequently asked questions
Do I need to know how to code before I start?
No, but you need to be able to read code, which is a lower bar. Follow our 30-day Python plan first if you have never written a line — it takes you to the point where you can read what the AI writes and catch it when it is wrong. Starting with zero Python is possible, but you will spend the whole build trusting output you cannot check, and that is how broken apps happen.
How long does the first app actually take?
A focused weekend: an hour for the spec, an hour for the scaffold, two to three hours of testing and fixing, half an hour to deploy. Students who take three weeks are not slower — they keep adding features. Three features, one weekend, one live link. Add features in week two, after the first version is already public.
Can I submit an AI-built app as coursework?
Usually yes, if you declare the AI assistance and can explain the code — but "usually" is not a policy. Check your course handbook or ask your lecturer first, and follow the three honesty rules above. Never submit code you cannot walk through.
What happens when my Replit app goes down after 30 days?
The published link stops working, but your code and data stay in the Replit workspace, so you can republish in about a minute for a fresh link. For a link that never expires, move the finished app to a host without an expiry — GitHub Pages works for simple front-ends — or upgrade to Replit Core at $20 a month ($18 a month billed annually) when a project actually needs it.
Is Copilot Student really free, and how do I get it?
Yes — free for verified students through GitHub Education, with unlimited completions and a small AI-credits allowance for chat and agent use. Apply with your student email or documents; GitHub re-checks eligibility every month. Until it is approved, Copilot Free gives you 2,000 completions a month with no card required — enough to build this app.
What if the AI writes code I do not understand at all?
Stop and shrink the problem. Ask the AI to explain the code in plain language, one function at a time, then rewrite that function yourself. If you still do not understand it, the feature is too big for your level — remove it, ship the smaller app, and come back after a week of Python practice. A small app you understand is worth more than a big app you cannot explain.
Ship it, then show it
The goal was never a perfect app. The goal was a real one: an idea, a spec, a scaffold, a debugging session, a live link, and the ability to explain every file to another human. That is a portfolio piece, a coursework submission, and — quietly — the moment you stop being someone who "wants to learn coding" and become someone who has shipped software. Build the tracker this weekend, put the link in your portfolio, then build the next one.

