Work With Me About Offerings Podcast
About Contact
Session Flow · Nathaniel Solace
Tutorial · Session Flow

Session
Flow.

The operating rhythm that makes every Claude session land. Five phases, sixteen moves, zero winging it.

Nathaniel Solace · ThoughtLeaderAI
The Problem

Most sessions start
with nothing.

Open Claude. Stare at the blank input. Type something. Hope it remembers what you were doing yesterday. It doesn't. So you spend the first ten minutes re-explaining your own project to your own tool.

Without session flow
Every session starts from scratch
Tasks slip between sessions
Mistakes repeat because corrections vanish
Builds start without loading the rules
Sessions end mid-thought
With session flow
60-second startup catches everything pending
Relay system bridges sessions automatically
Corrections become permanent memory
Every build starts with a declared loadout
Structured closeout, nothing left dangling
The Shape

Every session follows
the same shape.

Five phases, always in order. Some are 30 seconds. Some are the whole session. The shape stays the same whether you're building a landing page or fixing a single bug.

▶
Session Open
Employee sweep, relay intake, handoff check. Under 60 seconds.
⚙
Session Moves
16 engagement tactics. Active throughout. Situational, not sequential.
☰
Loadout
Before any build. Surfaces every rule and assumption that applies.
⚒
Build
The actual work. Code, copy, pages, systems. Starts aligned.
✓
Closeout
Dashboard sync, memory save, file check, placeholder audit, summary.
→
Handoff
Long sessions only. Structured bridge to the next chat.
Phase 1

Session Open

The first 60 seconds of every session. Before you bring the task, before you start typing what you want built, you let the system catch up. It reads every relay, every activity log, every pending handoff. Then it delivers a brief.

What Gets Checked
Employee registry confirms who is deployed and where their files live.

Relay intakes catch anything routed to an employee since the last session.

Activity logs surface what employees did while you weren't looking.

Outbound relays flag blockers and decisions that need your input.

Voice drops process anything you sent from your phone via Telegram.

Handoff tracker surfaces any open handoffs older than two days.
Phase 1 · Output

The result is a structured brief.

Every employee, every relay count, every blocker, every urgent item. All in one glance. If something is on fire, you know before you start working.

EMPLOYEE SWEEP
Felix (Gato): 2 relay pending / 1 activity / 0 outbound
Runa (Ritual Reboot): 0 / 0 / 0
Todd (Gold Pill Film): 1 relay pending / 0 / 0
...

VOICE DROPS: 1 pending
"Carousel idea for Thursday" (content, routed to Runa)

BLOCKERS: none
URGENT: none
Why This Matters
Without the sweep, tasks pile up invisibly between sessions. One missed relay becomes a two-day delay nobody notices until it's a problem.
Phase 2

Session
Moves.

16 engagement tactics used during the session to catch mistakes early, lock in good patterns, manage scope, and train Claude in real time. These are not steps. They're moves you use at the right moment.

Think of them in four clusters: correction, verification, steering, and maintenance.

Moves 1–4 · Correction

Catch it. Name it. Lock it in.

MOVE 01
The Correction Loop
"You used an em dash. That's banned because..."
Say why it was wrong, not just that it was wrong. The why turns a one-time fix into a session-long correction. If it reveals something non-obvious, it becomes a memory.
MOVE 02
The Assumption Surface
"What are you assuming right now?"
Forces Claude to declare hidden logic before it becomes a hidden mistake. Use it mid-build when something feels off or the direction seems slightly wrong.
MOVE 03
The Pattern Lock
"Yes, always do it that way."
Most people only correct mistakes. Locking in wins matters just as much. Without positive confirmation, Claude drifts away from approaches that already work.
MOVE 04
The Scope Check
"Is this getting too big?"
Two dimensions: task scope (the build is sprawling) and context scope (the session is holding too much). Say "scope check" and Claude reads which one it is. Often both.
Moves 5–8 · Verification

Trust, but verify.

MOVE 05
The Proof of Read
"Did you read that file or are you assuming?"
The most common source of hallucination: Claude writing confidently about something it never opened. This forces proof before it can reference or edit a file.
MOVE 06
The Replay
"Walk me through what you just did."
After a complex operation, make Claude narrate the steps. Catches silent changes, skipped steps, and the gap between what you meant and what it understood.
MOVE 07
The Rule Name
"Let's call that the form bridge pattern."
Name a pattern the moment you discover it. Unnamed rules get forgotten. Named rules become system components you can reference in every future session.
MOVE 08
The Relay Drop
"Log that for Felix."
Something needs to go to a different employee. Instead of context-switching, drop it as a relay. Keeps the current session focused. The relay system catches it next time.
Moves 9–12 · Steering

Keep it on course.

MOVE 09
The Mid-Session Checkpoint
"Where are we?"
Quick status pulse. What's done, what's left, has anything drifted. Not a handoff. Just a breath. Should take 30 seconds, not five minutes.
MOVE 10
The Memory Trigger
"Save that."
When something non-obvious surfaces, capture it immediately. Don't wait for closeout. Waiting means forgetting. The next session starts from zero on that insight.
MOVE 11
The Fork Question
"Should this be one thing or two?"
When a task has natural seams, ask early. The answer shapes file structure, naming, scope, and tracking. Prevents monoliths that should have been modular.
MOVE 12
The Constraint Injection
"Actually, this needs to work on mobile too."
Push in context Claude doesn't have before it's too late. Every constraint it doesn't know about is a potential rework loop waiting to happen.
Moves 13–16 · Maintenance

Keep the engine clean.

MOVE 13
The Density Check
"Compress that."
Strip filler from prompts and loaded context. Research shows compressing prompts by 40-50% produces better output, not just token savings. More dense = more accurate.
MOVE 14
The Learning Capture
"What did you learn from that?"
After a build completes, force Claude to articulate what worked and what failed. The answer gets logged. Turns every session into a training session for the system.
MOVE 15
The Context Reset
/clear
Between distinct tasks, drop accumulated context and start fresh. Every message in a long chat costs exponentially more than the same message in a new one. Don't carry topic A into topic B.
MOVE 16
The Budget Check
/cost and /context
Two commands that make invisible overhead visible. See what's eating your tokens, see actual spend. Use mid-session to pace yourself, or before deciding whether to compact or hand off.
Phase 3

The
Loadout.

Before building anything, Claude surfaces a short brief declaring every rule, convention, and assumption that will govern the build. You review it. Confirm or adjust. Then the build starts.

Rules only work if they're actively loaded, not just written down somewhere. The Loadout forces them onto the table before they can be missed.

The Principle
Declare first, build second. Every assumption visible before it becomes a mistake.
Phase 3 · Format

What a Loadout looks like.

Four sections. Build type, rules loaded, context loaded, and assumptions. The assumptions section is where the real value lives. That's where Claude says "here's what I think you mean" and you get to correct it before a single line gets written.

LOADOUT — Instagram Carousel for Thursday

BUILD TYPE:
Carousel (10 slides + caption)

RULES LOADED:
Anti-AI writing rules
HTML encoding: ASCII + entities only
Carousel captions complement, never repeat
Voice Guide consulted

CONTEXT LOADED:
Subfolder rules read: yes
Content pillar: sovereignty
Reference accounts reviewed

ASSUMPTIONS:
Public-facing, so anti-AI rules apply
Rendering via template system
Deploying to Netlify for webhook

Ready to build.
Phase 4

Session
Closeout.

Runs at the end of every session, even short ones. Six steps. Nothing gets left dangling.

01
Command Center Sync
Update the dashboard. Project states, last-touched dates, task progress. The command center must always reflect reality.
02
Memory Save
Save new memories discovered during the session. Update ones that changed. Remove ones that are stale.
03
File Verification
Confirm all files created or modified exist and aren't half-written. Quick pass, not a deep audit.
04
Placeholder Audit
No [PLACEHOLDER], no TODO, no example.com links in anything that's going to be deployed.
05
Clean Summary
What got done. What's pending. Where to pick up next.
06
Session Log
Append to the running log. Files touched, decisions made, anything outstanding. Searchable history across every session.
Phase 5

The Handoff.

When a session runs long enough that context starts degrading, Claude pauses and writes a handoff report. Structured bridge to the next session. Zero context lost.

What Goes In The Report
What was accomplished. Specific files, decisions, strategies confirmed.

In-progress items. Current state, file location, next concrete step for each.

Open decisions. Things discussed but not resolved. Pending choices.

Quick-start prompt. A copy-paste block that gets the next session up to speed in one message. Project name, current state, immediate next action.
The Trigger
Automatic when context gets heavy. Manual with "write a handoff" or "let's start fresh." Either way, the next session inherits everything this one knew.
The System

Each phase prevents
a category of failure.

The system works because it runs every time, not just when things go wrong.

Session Open
Dropped tasks, missed relays, stale handoffs, invisible blockers piling up between sessions.
Session Moves
Mid-build mistakes, scope creep, silent assumptions, lost corrections, context degradation.
Loadout
Wrong voice, missed rules, broken conventions, undeclared assumptions that become rework.
Closeout
Dangling files, out-of-sync dashboards, lost context, deployed placeholders.
Handoff
Context death between sessions. The thing that makes people feel like they're starting over every time they open a new chat.
Session Flow

Same shape.
Every time.

Open. Drive. Declare. Build. Close. Hand off if you need to. The rhythm stays the same whether the session is fifteen minutes or four hours.

The people who get the most out of Claude aren't the ones with the cleverest prompts. They're the ones with a rhythm that never drops the ball.

Nathaniel Solace · ThoughtLeaderAI
© 2026 Nathaniel Solace / Solace Labs. All rights reserved. · Terms & Conditions · Privacy & AI Safety