The Session Lifecycle: 8 Commands That Turn AI Coding Into a System

56 Commands Are Ingredients. This Is the Recipe.

Most developers install a set of AI coding templates and see a list of options. They pick one, use it, close the session. That’s like buying a gym membership and only using the water fountain.

The real power is the session lifecycle: a repeatable loop of 8 commands that turns every coding session into compounding progress. This is the exact workflow used to build a 97-page multilingual website, a PDF ebook in 4 languages, and an open-source CLI tool, all with AI doing the typing.

The Loop

Every productive AI coding session follows the same structure:

1. Resume (/read-handover). Pick up where the last session left off. The previous session saved a HANDOVER.md with completed work, decisions made, rejected alternatives, and exact next steps. The AI absorbs all of this before touching anything.

2. Prioritize (/strategic-next). Before doing anything, determine the highest-impact work. Run a full project audit, brainstorm opportunities, evaluate them on an Impact/Effort matrix. Build the thing that matters, not the thing that feels urgent.

3. Explore (/creative-brainstorm). Once you know WHAT to build, explore HOW. Reframe the problem multiple ways. Generate ideas through different lenses: invert it, remove it, simplify it, overkill it. Converge on the best approach. Avoid the first-idea trap.

Then you build, using whatever template fits the work: /feature-build for features, /quick-task for small changes, /debug-rootcause for bugs. The planning phases already set the direction. Execution is the 20%.

4. Verify logic (/verify-thorough). Five verification layers: logical (does it make sense?), contextual (does it fit the system?), completeness (all paths handled?), empirical (actually run it), regression (did it break anything?). “It looks right” is not verification.

5. Verify visually (/visual-verify). Logic catches functional bugs. Visual verification catches everything else: responsive layouts across desktop, tablet, and mobile. Console errors. Network failures. Interaction testing. Screenshots as evidence.

6. Audit standards (/principles-check). After the code works and looks right, check it against your engineering principles. KISS, DRY, YAGNI, SRP, security, testing, documentation. Every violation gets an exact file:line citation.

7. Clean up (/housekeeping). Documentation accuracy. Dead code removal. Dependency audit. Git hygiene. Consolidation. Leave the codebase better than you found it.

8. Save state (/low-context-handover). Save everything: what happened, what’s completed, what’s in progress, decisions and rejected alternatives, known issues, exact next steps. This connects back to step 1 of the next session. The loop is closed.

Eight commands. One loop. Every session.

Why Each Step Matters

The steps are not arbitrary. Each one prevents a specific failure mode.

Without handovers, every session wastes 10 to 20 minutes re-establishing context. Over 50 sessions, that’s 8 to 16 hours lost to rediscovery.

Without strategic planning, you drift. You fix low-priority bugs while critical features sit unbuilt. You optimize CSS while the payment flow is broken.

Without brainstorming, you build the first thing that comes to mind, then refactor it later when a simpler approach existed all along.

Without dual verification, you ship code that works in the demo and breaks in production. Or works perfectly but looks broken on mobile. The 48% verification gap (Sonar, 2026) is where bugs live.

Without principles audits, your codebase slowly accumulates “just this once” exceptions until your standards are a memory.

Without housekeeping, mess accumulates. Stale docs mislead. Dead files confuse.

Each step is a safety net. Together, they form a system where nothing slips through.

The Parallelism Multiplier

The loop is powerful for one project. It becomes a force multiplier when you run multiple projects simultaneously.

One project per IDE. One IDE per Claude Code session. Multiple IDEs open at the same time:

• IDE 1: Building a website
• IDE 2: Writing an ebook
• IDE 3: Developing a CLI tool
• IDE 4: Preparing marketing content

Each project runs its own lifecycle. Each produces its own handover. When you switch back to a project, /read-handover picks up exactly where you stopped. The handover system means you can juggle ten projects without losing context in any of them.

Without handovers, switching between projects means re-establishing context every time. With handovers, the AI picks up in seconds. The session lifecycle is the same in every project, so the cognitive overhead of switching is near zero.

Start Simple, Add Layers

You do not need all 8 commands on day one.

Week 1. Start with /kickoff and /low-context-handover. Just begin and end sessions properly. That alone puts you ahead.

Week 3. Add /read-handover and /verify-thorough. Now you preserve context across sessions and catch bugs before they ship.

Month 2. Add /strategic-next and /visual-verify. Now you build the right things and prove they work visually.

Month 4. The full 8-command loop plus parallelism across multiple IDEs.

This progression mirrors the belt system from martial arts. You build muscle memory at each level before adding the next layer.

The Compound Effect

Each command is useful alone. Together, they compound.

Handovers eliminate context loss, so decisions persist across sessions. Strategic planning prevents drift, so you build what matters. Brainstorming prevents first-idea bias, so you build it the right way. Dual verification catches bugs early, so there is less debugging later. Principles audits prevent decay, so the codebase stays clean. Housekeeping prevents mess, so the codebase stays navigable. Parallelism multiplies throughput.

After 50 sessions with this loop, you have built the equivalent of what would take a small team months. Not because AI writes faster code, but because you never lose context, never build the wrong thing, and never ship unverified work.

That is the methodology. Not a collection of templates. One loop, executed consistently, compounding over time.

The tools to run this workflow are free and open source. Install them with npx @ccprompt/cli install-generic . and start with /kickoff. The full methodology explains the principles behind each step.