Every AI coding assistant is good at the same thing: changing code that already works. They're much shakier at inventing an app from a blank page. The catch is that "good at changing existing code" only holds if the assistant actually understands what it's looking at first — and if you skip that step, it doesn't ask permission before guessing. It just writes something, and what it writes fights the patterns already in your app instead of following them.

This matters more than usual when the code isn't yours to begin with. You didn't write it, so you can't catch a wrong guess by instinct the way the original author could. The fix isn't complicated, but it is a specific first step, and skipping it is the single most common reason people get frustrated with AI coding tools in the first few days.

Give it a map before you give it a task

Don't open with a feature request. Open with an orientation request — one conversation that either produces a correct understanding you can build on, or catches a wrong one while it's cheap to fix.

Open a new conversation, attach your app's README.md and one core structural file (a database schema, a models file, whatever defines your data's shape), and say something close to this:

"These are the core structure and documentation files for an app I own the source code to. Read them and give me back, in plain language: what the app does, what the main pieces of data are, and how a user moves through it. Don't suggest any code changes yet — I just want to check that you understand its architecture."

That last sentence matters. It keeps the assistant in read-and-reflect mode instead of jumping straight to a fix.

Read what comes back and check it against what you actually know: does it name the right pieces of data, describe the app correctly, get the user's path through it right? If yes, you have a correct mental model to build on. If not, correct it right there — a wrong assumption caught in this conversation costs a sentence; caught three features later, it costs a rewrite.

Make it permanent with CLAUDE.md

That conversation is worth having once — but having it again at the start of every new session is the part worth eliminating. If you're using Claude Code (Anthropic's coding CLI), you can make that understanding permanent instead of repeating it: a file called CLAUDE.md, sitting in your project's root folder, gets read automatically before every single prompt in that project — not just the first one, every one, from then on, without you doing anything.

The fastest way to create one: once the orientation conversation above has gone well, just ask — "Save what you now understand about this app's structure and conventions into a CLAUDE.md file, so future sessions start with this context automatically." You'll get a first draft in seconds, which you can then edit like any other file. It's just plain markdown — nothing to install or configure.

A good CLAUDE.md for a template app usually covers:

  • What the app is and who it's for, in one or two sentences — the same summary you'd give a new hire.
  • The shape of the architecture — frontend/backend/database split, where each lives, and the pattern each layer follows.
  • Project-specific conventions — naming rules, folder structure, things this codebase always does a particular way.
  • Standing instructions — things you always want followed (or avoided) without repeating them: "always update both READMEs when config changes," "never hardcode colors, use CSS variables," that kind of rule.

That last category is the one people underuse. Anything you find yourself correcting an assistant on more than once belongs in CLAUDE.md instead of your next message — write it there once, and it's enforced automatically from then on, for every future request, without you having to remember to mention it again.

If you're not using Claude Code, there's no automatic file-loading — the manual orientation prompt above is what you'll repeat at the start of each new session, or whenever a conversation gets too long and cluttered to keep reusing.

Why this pays off more the longer you use it

The first time you do this, it feels like a slow extra step before you get to the part you actually wanted (the feature). In practice it's the opposite of slow: every request after this one lands closer to correct on the first try, because the assistant is extending a structure it actually understands instead of pattern-matching against a guess. Skip this step and you'll spend that same time later, undoing changes that technically worked but didn't fit how the rest of the app was built.

Key Takeaways

  • Orient before you request. Ask the assistant to explain the app's structure back to you before asking for any change.
  • Attach the right two things: your README and one file that defines your data's shape (schema, models file).
  • Check its summary against what you know. A wrong assumption caught here costs a sentence; caught later, it costs a rewrite.
  • Make it permanent with CLAUDE.md. In Claude Code, this file is read automatically before every prompt — write your app's structure and standing conventions into it once, instead of re-explaining them every session.
  • No Claude Code? Repeat the manual prompt. Without automatic file-loading, the orientation conversation is what you'll reuse at the start of each new session.