How do you work with Claude Opus 5 on long projects?

Claude Opus 5, released by Anthropic on July 24, 2026, is built for the kind of work that runs longer than a single chat: multi-step coding, analysis and document projects. Anthropic says it is much better than earlier Opus models at checking its own work and iterating until it succeeds. One example from the launch: when no live data feed existed to test against, it built its own test harness to confirm its code read an exchange's data correctly. It is the default model on Claude Max, available on Pro, and on the API as claude-opus-5 priced at $5 for each million tokens of input and $25 for each million of output.

A capable model still has a basic limit on long projects. Each session works inside a context window, the amount of text the model can hold at once, and a new session starts with no memory of the last one. Anthropic's engineers compare it to a team working in shifts where every new engineer arrives knowing nothing about the previous shift. The routine below fixes that by keeping the project's memory in files.

The routine: plan, checkpoint, review

Plan. Before any code or drafting, ask Opus 5 to explore and plan without building anything. Anthropic's Claude Code guidance recommends exactly this order: explore, plan, then code. The plan becomes a feature list, a file in which every piece of the finished project is described as a testable item, all marked as not yet passing.

Checkpoint. Each working session takes one item from the list, builds it, tests it, then records a checkpoint: a git commit with a clear message and a few lines in a progress log. Git is version control software that saves snapshots of your files, so any bad change can be undone.

Review. At points you choose, such as every three items or at the end of each day, you read the progress log and the changes and try the result yourself before the next round starts.

A worked setup

Say you want Opus 5 to build a small booking website for a community hall. Three files make up the project's memory:

FEATURES.json    <- every feature, each with "passes": false at the start
PROGRESS.md      <- dated notes: what was done, what broke, what is next
init.sh          <- one command that starts the site for testing

One entry in the feature list might look like this:

{
  "id": "booking-form",
  "description": "A visitor can pick a free date, enter a name and email, and see a confirmation",
  "test": "Open the site, book the first free date, check the confirmation and that the date is now taken",
  "passes": false
}

Anthropic found JSON works better than Markdown for this list, because the model is less likely to rewrite or overwrite a JSON file by mistake. The first session's prompt sets everything up:

Read the project brief in BRIEF.md. Do not write application code yet.
1. Create FEATURES.json listing every feature as a testable item, all with "passes": false.
2. Create init.sh to start the development server.
3. Create PROGRESS.md with today's date and a short summary of the plan.
4. Make the first git commit.
You may only ever change the "passes" field in FEATURES.json, never delete or reword features.
Stop when done and show me the feature list.

Every later session starts with the same short prompt: read PROGRESS.md and the last 20 git commits, run init.sh and check the basics still work, pick the highest-priority failing feature, build and test only that, then commit, update PROGRESS.md and stop.

How do you keep it on track over many hours?

Make it work on one thing at a time. In Anthropic's experiments, the two biggest failures on long projects were trying to do everything at once, which left half-finished, undocumented work when the context ran out, and declaring the job done too early because some progress was visible. A feature list with explicit pass marks answers both: the model can see exactly what remains, and "done" means every item passes.

Insist on real tests. Anthropic also saw its models mark features complete after only partial checks. Results improved sharply once the model was told to test as a user would, for example with browser automation that clicks through the site. Put the test in each feature description, as in the example above, and ask for evidence such as test output or screenshots in the progress note.

Let the files carry the memory. Context tools such as compaction, where earlier conversation is summarized to free up space, help but are not enough on their own; the progress log and git history are what let a fresh session understand where things stand in minutes. If a session goes wrong, revert to the last good commit rather than asking the model to untangle the mess.

Keep your review points. Opus 5 is more careful than earlier models, and its customers report that it pushes back on flawed designs and verifies before handing work over. That makes your reviews faster, not unnecessary. Leave permission prompts on for actions that change or delete things, and use the effort setting to match the job: higher effort for planning and hard bugs, lower for routine items, which also saves tokens.