Ways to run it for real
Once it is live, running it for real is its own kind of AI work. These are the moves that keep a live system honest. Unlike the on-ramps to Sharpen, you combine these rather than pick one.
Hold the context
Anything important that lives only in the chat is at risk, because a long conversation gets compacted as it grows and a summary blurs the precise things, the amounts, the dates and the decisions. Over a long session or a big codebase there is a second drift too, the answers start going generic, reaching for what a project like this usually looks like instead of what was actually found. Holding the context means keeping the real findings in a durable place outside the chat, so the next turn and the next session both start with them already in hand rather than with a guess.
Say it another way
Context here means everything the AI is currently holding in mind about your work. In a long session it gets squeezed into a summary as it fills up, and the precise bits, the amounts, dates and decisions, can blur. So you write the important things down somewhere solid rather than trusting the chat to remember.
Doing this with Claude Code: Hold the context
Keep the decisions and the hard facts where you and Claude can both find them, in a place that survives the conversation. A CLAUDE.md and project memory, a rolling STATUS file, sessions you can name and resume. The chat itself is not that place: as it grows long Claude compacts it, dropping bulky tool output first and then summarising the older history. A summary blurs exactly the precise things you needed kept, the amounts, the dates and the decisions.
Holding the context earns its keep in five ways: keep the facts outside the chat, put what matters where it is read, trim the noise, hand facts cleanly between agents and keep a long exploration sharp.
Keep the facts outside the chat. Put the amounts, dates, IDs and decisions in CLAUDE.md, project memory or a STATUS file, not only in the conversation. Memory reloads at the start of every session and CLAUDE.md sits outside the history, so compaction cannot round them off, like a master recipe pinned to the wall rather than cooked from memory of what was said earlier.
Put what matters where it is read. Claude leans on the start and end of a long input and is least reliable through the middle, so lead with the key facts and signpost them with headers rather than burying a make-or-break detail in the middle of a wall of text.
Trim the tool output. A command that hands back forty fields when five matter quietly fills the window and pushes the real facts toward the lossy middle. Ask for only the fields you need, or filter the output, so the noise never lands in the context in the first place.
Hand facts cleanly between agents. When a subagent does a piece of work, have it return the distilled facts with where, when and how it got them, not the whole verbose haul, so the main session can trust and combine them without drowning in detail.
Keep a long exploration sharp. Over a long session the model drifts to generic typical-pattern answers as it loses grip on the specifics. Counter it the same way: keep a scratchpad of what you actually found and refer back to it, push verbose discovery into a subagent so the main thread stays clean, then reach for /compact when the context fills. Each pass then stays grounded in this codebase rather than a generic one.
Know when to step in
Decide in advance what AI handles and what comes to you. Escalation and human-in-the-loop are a design choice, not an afterthought. Name the triggers that hand it back to a person.
Say it another way
Human-in-the-loop just means deciding ahead of time which actions the AI may take on its own and which must stop and wait for you to approve. You set that line on purpose, rather than discovering it after the AI has already done something you would not have allowed.
Doing this with Claude Code: Know when to step in
Decide up front what Claude handles on its own and what pauses for you, then draw that line in the instructions with worked examples rather than leaving it to in-the-moment judgement. Permission settings and review gates enforce it, so risky or far-reaching actions stop and ask instead of running ahead.
Knowing when to step in earns its keep in four ways: escalate on the real triggers, honour a handover at once, do not escalate on mood and ask rather than guess on ambiguity.
Escalate on the real triggers, not on difficulty. Hand back when there is an explicit request to do so, when the situation falls into a gap the rules do not cover, or when it cannot make progress. A hard case it can still work through is just work, not a reason to escalate.
Honour an explicit handover at once. When someone asks for a person, hand off immediately without another round of questions and pass on the context already gathered, so they pick up warm rather than cold.
Do not escalate on mood or self-confidence. An annoyed tone, or the model's own reported confidence, is a poor proxy for whether a case really needs a human. Acknowledge frustration and still offer to resolve it, escalating only if they insist.
On ambiguity, ask rather than guess. When a lookup returns several matches, ask for another identifier instead of picking one, because acting on the wrong record is far worse than one more question.
Fail well
Make failures surface clearly, with enough context to recover, instead of being swallowed or guessed around. A live system that fails loudly and recoverably beats one that fails quietly.
Doing this with Claude Code: Fail well
Make failures surface clearly, with enough context to recover, instead of being swallowed or guessed around. Ask Claude to report and stop when something is wrong rather than press on and improvise. A live system that fails loudly and recoverably beats one that fails quietly and leaves you guessing.
Review with fresh eyes
Have a second, independent AI pass look at the work without the context that built it. A fresh instance catches what the one that wrote it cannot see.
Doing this with Claude Code: Review with fresh eyes
Have a second, independent pass look at the work without the context that built it. A fresh Claude session, or a separate review step, catches what the one that wrote it cannot see. The instance that did the work is too close to spot its own blind spots, so bring in eyes that start clean.
Putting it together
These are not a sequence, they are a set. A live system that holds its context, knows when to step in, fails well and gets reviewed with fresh eyes is one you can put your name on.
In plain words
In plain words: this page is about life after launch, once real people are using what you built. The job shifts from making it to keeping it trustworthy: hold on to the important decisions so they are not lost, decide in advance what the AI handles alone and what it must hand back to you, make failures show up clearly instead of hiding, and have a fresh set of eyes review the work. AI here is a tool that can run parts of a live system for you, within limits you set.
Part of Working with AI.
These moves run across the Launch ideas.
The soft skills behind them: The soft skills of working with AI.
Why Claude. We use Claude Code in the notes above because it is one of the most widely used AI tools for building software. It is also what we build with day to day. The moves themselves are general and carry across to other capable AI tools.