The app that stopped getting better
You have probably built something by chatting with an AI: a to-do app, a quiz, a small game. You typed an idea, the AI wrote the code, and it worked. Then you asked for more features, and things went wrong. Old features stopped working, the AI forgot decisions you had made, and the app never got beyond the chat window.
This is not your fault. Chat-only building has four built-in limits. In this level you will learn to name each one and spot its symptoms. Then you will see what changes when the code lives as a real project on your own computer.
Limit 1: The Context Window
What it is: A context window is all the text an AI model can see while it writes a reply. That includes your messages, its earlier answers, any code pasted into the chat, and the reply it is writing now. Anthropic's documentation calls it the model's "working memory". It is measured in tokens, which are small chunks of text, often parts of words.
Analogy: Picture a desk that can only hold so many sheets of paper. Each message adds a sheet. When the desk is full, older sheets get pushed off the edge or squashed into a short summary.
Why long chats break:
- Every version of your app that the AI prints out goes onto the desk. A 300-line game printed ten times fills it quickly.
- When a chat gets too long, some chat apps drop or summarise the oldest messages. The exact details of your early code can be lost.
- A bigger window does not fully fix this. As of October 2026, some models accept about a million tokens. Anthropic still notes that accuracy and recall get worse as the context grows, which it calls context rot.
Symptom: You ask for a new feature, and the AI rewrites the file without a feature you added an hour ago.
Limit 2: No Reliable Memory Between Chats
When you start a new chat, the model does not automatically have your code in front of it.
Some chat apps now offer memory features. ChatGPT can refer back to saved memories and past chats, and Claude can build memory from your chats. These features keep summaries and preferences, though, not a full and exact copy of your project. OpenAI's own help pages say chat history does not keep every detail. These features also change often, so check your tool's current help page.
Symptom: In a fresh chat you say "add a high-score table to my game", and the AI invents a new game structure that doesn't match your real code.
Limit 3: No History of Changes
A chat is a scroll of messages, not a record of versions.
- There is no simple list of "what changed, when, and why".
- You can't easily compare today's code with yesterday's.
- If the AI breaks something, going back means scrolling for an old copy and hoping it was complete.
Symptom: "It worked yesterday!" But you can't tell which of the last fifteen replies broke it, or which earlier copy was the last good one.
Limit 4: Nothing Running Online
A chat preview runs inside the chat service. Some tools let you publish or share a link to what you built. That is useful for showing a demo, but it is not the same as an app that you control.
- It has no proper home for saved user data, such as accounts or scores that last.
- It can't easily connect to other online services.
- It depends on that one chat product and its rules.
Symptom: A friend asks, "Can I sign up and save my progress?" Your app can't do that.
Task: Diagnose Your Own Chat-Built App
Do this now with any app you have built in a chat. You will only read and write notes, and you won't change anything.
- Open your longest chat for that app.
- Context check: Scroll back. Did a feature ever disappear after a later request? Write down one example.
- Memory check: Have you ever started a new chat and had to paste or explain everything again? Note it.
- History check: Try to find the last version that you know fully worked. Note how long that took.
- Online check: Write down where the app runs today, for example "only in the chat preview" or "a shared link".
- Save your notes in a plain text file. You will use them in later levels.
What Changes With a Real Project
When your code lives as files on your own computer, each limit gets a fix:
| Limit | In a chat | In a real project |
|---|---|---|
| Context | The whole app is pasted again and again | A coding agent opens only the files it needs, when it needs them |
| Memory | Lost or summarised between chats | The files are the memory, and a project instructions file can explain your rules |
| History | Scrolling through old messages | Version control records every save point (covered later in this course) |
| Online | Stuck inside the chat tool | Code can be backed up and connected to hosting services (covered later) |
The main shift is this: your code becomes the source of truth, not the conversation. The AI still does most of the typing. Your job is to understand and check what it does.
Key Takeaways
- A context window is everything the AI can see at once. Long chats fill it, and early details get dropped or summarised.
- Context rot means accuracy can drop as the context grows, even in very large windows.
- Chat memory features keep summaries and preferences, not your exact code.
- Chats have no history of changes, so going back to a working version is hard.
- A chat preview or shared link is not a full online app with saved data and connected services.
- In a real project, the files on your computer hold the truth, and tools are built around them.