Opening a new AI coding session often starts with an exhausting task.

Re-explaining the entire project.

Why the product is designed this way, why previous attempts were abandoned, which files are off-limits, which tests have passed, and what requirements the user just changed. You keep copying and pasting old conversations, and the context window is quickly filled with the past.

By the time you finally finish explaining the background, the actual action you need to complete right now becomes blurry.

You Don't Lack Background; You Lack a Starting Point

Of course, a project needs long-term memory. The problem is that the complete history and the current action are not the same thing.

Chat logs, PRDs, commit histories, and scratchpads are responsible for saving what has happened in the project. A new session, however, needs to answer a different set of questions:

  • What is the desired outcome this time?
  • What facts have been confirmed by evidence?
  • What constitutes "done"?
  • What other risks or boundaries might change our choices?

If these four things aren't clearly stated, even the longest history might just be noise. The Agent might be able to recite the project's history, but it won't necessarily know what to do next.

Context Isn't About Quantity; It's About Relevance

Stuffing all old conversations into a new window seems like the safest bet, but it actually creates new problems.

Outdated decisions appear alongside the latest requirements. Unverified guesses mix with real evidence. Tangential discussions hijack attention away from current boundaries. Ultimately, the user has to manually explain what to trust and what is no longer valid.

Truly effective context doesn't strive to be the largest, but the minimum sufficient.

"Minimum" doesn't mean omitting important facts; "sufficient" doesn't mean duplicating the entire archive. It only retains the information that affects the judgment and outcome of the current step.

A Solid Handoff Only Requires Four Elements

1. The Goal for This Round

The goal should ideally be an outcome that can be judged as complete or not.

"Continue optimizing the product" is too broad. "Identify the root cause of the login failure and verify the fix hypothesis using the narrowest user path" is much clearer.

A specific goal tells the Agent what evidence to collect, where not to expand, and when to stop diverging.

2. Historical Evidence

What you bring into a new session should be verified facts that affect this round's judgment, not the entire discussion process.

What a specific API actually returns, which tests have passed, and which solution was rejected (and based on what evidence)—these details prevent the next session from taking detours.

Unverified guesses can be kept, but they must be explicitly labeled as "to be verified" and not disguised as conclusions.

3. Definition of Done

The definition of done turns "keep working" into a task that can actually end.

Whether the code is deployed, whether the real user path is successful, whether the final artifact can be parsed, whether the release receipts are complete, or whether regular users will still see engineering traces—all of these can serve as completion criteria.

The closer the standard is to the result the end-user gets, the less likely you are to prematurely declare victory just because the happy path works.

4. Open Risks and Boundaries

Only include constraints that will directly alter the choices made in this round.

For example, a frozen baseline cannot be changed, existing user modifications must be preserved, or a specific release channel can currently only generate drafts.

The purpose of boundaries is to protect the goal, not to force the user to bear the system's internal complexity. Implementation details irrelevant to this round's action should remain in the implementation layer.

A Handoff is a Baton, Not a Warehouse

A complete chat history is like a warehouse. It stores a lot, but the next executor still has to dig through it themselves.

A step handoff is more like a relay baton. It should allow the next execution to see at a glance:

  • Where to pick up;
  • Which conclusions don't need to be redone;
  • What evidence must be respected;
  • How far to run before handing off the baton.

Old conversations can still be referenced, of course, but they shouldn't continue to serve as the main entry point for starting work every time.

Start from the Current Step, Not from Project Archaeology

SoloMap places this starting point right next to the project roadmap.

You select the current step you want to advance, and initiate the Agent conversation from there. The step's goal, existing evidence, definition of done, and handoff information become the starting point for this session.

The project's long-term context stays within the project; the new session only gets the parts truly needed to complete the current action.

This doesn't mean the user loses control. On the contrary, your highest priority request for this session must override old plans. A production outage, a market shift, or an ad-hoc release can all change what the right action is today.

Good starting context provides a stable baseline, but the final direction is still up to you.

Now, Take 15 Minutes to Test This

Find a real step where you recently got stuck, and open a new Agent conversation.

First, write just four lines:

  1. The goal for this round;
  2. Verified evidence;
  3. Definition of done;
  4. Open risks.

Then add one more sentence: What is the highest priority request today?

Finally, review every piece of old background you were about to paste. If deleting it doesn't affect the current choice, don't bring it into the new session.

The goal of this exercise isn't to write prettier prompts, but to make the conversation start with action.

Next Time You Resume a Project, Don't Start from Scratch

A truly continuous project isn't one where every session remembers more, but one where every session can resume from the right place.

Leave the complete history to verifiable project records, give the minimum sufficient context to the current step, and keep the final judgment call for yourself.

The next time you open a new session, don't re-explain the entire project.

Select a step, and start from the next action.

Install SoloMap from the VS Code Marketplace, select the current step for a real project, and launch your first bounded Agent conversation.