AI Gets Tunnel Vision. And If You're Not Technical, You Won't Notice.

You're twenty messages into a conversation with AI. You've explained your project, your requirements, your constraints. You've been specific. You've been clear. And now, on message twenty-one, AI generates code that ignores half of what you said.

You told it the app needs authentication. It built the feature without checking if the user is logged in. You told it prices need to include tax. It calculated everything without tax. You told it the form has a character limit. It forgot the character limit.

You didn't do anything wrong. AI just stopped paying attention.

What's actually happening

AI doesn't have memory the way you do. It has a context window — a fixed amount of text it can "see" at once. Think of it like a window sliding over a long document. As the conversation gets longer, earlier parts fall off the edge. AI can see what's in the window right now. Everything else is gone.

But it's worse than simple forgetting. AI doesn't tell you when it's lost context. It doesn't say "I can no longer see your original requirements." It just proceeds as if those requirements never existed. It generates confident, clean, working code that doesn't do what you asked — and it has no idea it's wrong.

This is tunnel vision. AI focuses intensely on the immediate task you just asked about and loses sight of the bigger picture. The longer the conversation, the worse it gets. By message thirty, AI is essentially a fresh assistant that happens to remember the last few things you said.

Why developers catch it and you don't

When a developer works with AI, they have a mental model of what the code should look like. They read what AI generates and notice what's missing. "This function doesn't check permissions." "This query doesn't use the index I set up." "This form handler doesn't validate input." They catch the omissions because they know what correct looks like.

If you're not technical, you can't do this. The code AI generates looks like code. It runs. It appears to work when you test the happy path. You don't notice that it forgot to handle the edge case you mentioned in message seven, or that it removed the rate limiting you asked for in message twelve, or that the database query it wrote will bring your server to its knees at a hundred users.

This isn't about intelligence. It's about vocabulary. A developer has the vocabulary to read code and spot what's missing. Without that vocabulary, AI's output is a black box — and you're trusting the box to remember everything you told it.

The repetition tax

Once you realize AI forgets, the natural response is to repeat yourself. Every few messages, you re-state your requirements. "Remember, this needs authentication." "Don't forget about the tax calculation." "The character limit is 500, like I said earlier."

This works, sort of. But it creates a tax on your time and attention. You're now spending a significant chunk of every interaction reminding AI of things it should already know. You become the memory system. You become the context manager. Instead of AI helping you, you're helping AI stay on track.

And you can only remind it of the things you remember to remind it of. The requirements you forget to re-state are the ones that quietly disappear from the output. You might catch the missing authentication because that's obvious. But what about the subtle things — the error handling, the input validation, the edge case where two users submit at the same time? Those vanish silently, and you don't know they're gone until something breaks in production.

The cascade effect

AI's tunnel vision doesn't just drop individual requirements. It creates cascading problems.

Say you're building a booking system. In message five, you told AI that bookings need to check availability before confirming. In message fifteen, AI builds a new booking flow for a different page. It doesn't check availability. Now you have a system where double-bookings are possible from one page but not another.

You don't notice until a customer books a slot that's already taken. Now you're dealing with an angry customer, a broken booking, and a codebase where the same rule is applied in some places and not others. You ask AI to fix it, and AI fixes the one page you pointed to — but there might be a third page, a fourth page, an API endpoint that also creates bookings without checking availability. AI won't audit the whole system unprompted. It fixes the thing you pointed at, right now, in this message.

This is how AI-built apps accumulate inconsistencies. Not through one big failure, but through a hundred small omissions that compound over time.

What AI should do but doesn't

In an ideal world, AI would maintain a running checklist of your requirements and verify each one before generating code. It would say: "I'm about to build this feature. Let me confirm it meets the requirements you've stated: authentication check, tax calculation, character limit, availability check. Does that look right?"

AI doesn't do this. It responds to the immediate prompt and generates what seems right in the moment. It doesn't cross-reference with earlier parts of the conversation. It doesn't self-audit. It doesn't flag when it's uncertain whether a requirement still applies.

Some developers work around this by maintaining a separate document — a requirements list, a system prompt, or a project specification — that they paste into every conversation or keep at the top of the context. This is effective, but it requires you to know what belongs on that list. It requires you to think like a developer about what could go wrong. And it requires discipline to keep the document updated.

The expert as context keeper

This is one of the less obvious reasons why working with a human expert changes the outcome. An expert doesn't have a context window. They build a mental model of your project that persists and grows. When you tell them about a requirement in week one, it's still in their head in week four — not because they memorized it, but because it's part of their understanding of the system.

When an expert reviews AI-generated code, they're not just checking if the code works. They're checking if it's consistent with everything they know about the project. "This function doesn't check permissions — but the rest of the system does. That's a bug." They catch the omissions because they hold the full picture, not just the last few messages.

More importantly, an expert asks you about the things you haven't mentioned. "What happens if two people book at the same time?" "Do you need this to work offline?" "What about users on the free plan — do they see this feature?" These questions come from experience, not from scrolling up in a chat history. They come from knowing what goes wrong in systems like yours, because they've seen it before.

AI can't compensate for its own blind spots. A human can.

What to do about it

If you're working with AI and you're not technical, here's the reality: AI will forget things. You need a strategy for that.

Keep a requirements document. Write down every requirement, constraint, and rule as you go. Paste it into the conversation periodically. This is your external memory for AI.

Test more than the happy path. Don't just test that the feature works when everything goes right. Test what happens when you enter bad data, click things twice, leave fields empty, use a different browser. The bugs AI introduces by forgetting requirements show up in edge cases.

Start fresh conversations for new features. Long conversations are where context loss is worst. If you're starting a new feature, start a new conversation and re-state the relevant requirements up front.

Have someone technical review before shipping. Not after it breaks. Before. A developer reviewing AI-generated code will catch the missing authentication, the unvalidated input, the inconsistent business logic — the things you can't see because you don't read code.

AI is a powerful tool. But it's a tool with a specific weakness: it forgets. And the people who are most vulnerable to that weakness are the people who need AI the most — the ones who can't tell when it's lost the plot.