Save Point Technique 260126

The Save-Point Protocol

A Guide to Iterative Discovery and Systematic Scripting

"We have the patience to slowly learn our way through the dark."

1. The Concept

Most staff try to sprint from a problem to a solution in one go. When they fail, they get lost and have to start over.

The Save-Point Protocol is a technique for navigating complex problems (the "dark") by creating stable, clean anchors ("Save Points") as you progress. It combines our Lean Backward Strategy with Tactical Scripting.

2. The Core Philosophy

• Discovery, Not Construction: We often don't know the exact path. We are discovering it.
• Artifact Hygiene: Dirty data (formatting glitches, partial thoughts) kills momentum. We use Code Blocks to keep our tools sharp.
• Comparative Rigor: We don't trust the first answer. We test against multiple intelligences (Claude, Gemini, Deepseek).

3. The Workflow

Phase 1: The Anchor (Lean Backward)

Before writing a single script, you must define the "Game Win" state.

• Reference: Lean Backward Design Guide
• Example Plan: Sample Plan Document
• Technique Example: Backwards Analysis and Design Techniques
• Action: Write down the Outcome.
  • Example: "I need a Python script that scrapes X and formats it as Y."
  • Not: "I'm going to try using Python."

Phase 2: The "Save Point" (The Code Block)

In Lean Backward Design, we identify specific Actions and Requirements to reach our goal. This focuses our work on producing a tangible Proof of Concept (POC) or MVP. We don't build the whole system at once; we iterate little by little.

This phase is the technical safety net for that iteration. As you execute those actions with AI or your own coding:

1. Use Code Blocks Only: Never copy-paste plain text for scripts or prompts. Always use Markdown code blocks (```).
2. Why?
   • Zero Artifacts: It strips smart quotes, weird indentation, and rich text formatting that breaks code.
   • Portability: You can lift a code block from a Note and drop it into Gemini, Claude, or a terminal without cleaning it.
3. The "Save Point" Rule:
   • Once a script works partially (meeting one of your identified Requirements), you save it in a code block.
   • Describe the Gap: You must explicitly write down what went right, what went wrong, and what didn't work.
   • Context for AI: This text is not just for you; it is for the AI. These notes become the prompt for the next iteration, helping the AI understand exactly where the previous attempt failed.
   • This combination (Code + Gap Analysis) is your Save Point.
   • If your next attempt fails, reload from the Save Point. Do not try to fix the broken mess; return to the clean state.

Phase 3: The Multi-Model Benchmark

We do not rely on a single oracle.

1. Take your "Save Point" script/prompt.
2. Run it through Claude (for reasoning/structure).
3. Run it through Gemini (for speed/multimodal).
4. Run it through Deepseek (for coding logic).
5. Compare the outputs. The differences reveal what you didn't know you didn't know.

4. Example Usage: "The Dark Room"

Scenario: You are building a complex automation but don't know the API.

1. Start (Lean Backward): "Outcome: A list of client emails."
2. Attempt 1: Ask AI for a script. It fails.
3. Attempt 2: You refine the prompt. The AI gives a script that connects but doesn't list.
4. SAVE POINT: You copy that "connecting" script into a clean Code Block in your notes.
   • Tag: [Save Point: Connection Established]
5. Attempt 3: You try to add the "listing" feature. The script breaks completely.
6. Reload: You discard Attempt 3. You go back to the [Save Point: Connection Established] block and try a different approach.

5. Summary for Teams

If you are lost, check your Save Points.

• Do you have a clean, working version of your previous step?
• Is it in a Code Block (clean of artifacts)?
• Have you compared your results?

Don't wander in the dark. Build a path of light, one Save Point at a time.