Run the plan-execute-verify loop

Lesson outcome

You will have completed one real task using the full plan-execute-verify cycle and will understand the rhythm well enough to use it instinctively.

Why this matters in an agency

This is the operating loop for any significant work. Plan mode is not a feature you use occasionally — it is the default approach for work that matters. Client deliverables, SOPs, tool development, vault reorganization, campaign planning — all of these benefit from explicit planning, bounded execution, and structured verification. This lesson makes the loop concrete so you can repeat it independently.

Inputs, tools, and prerequisites

Claude Code running on the VPS. Your vault with 20+ notes. A real task from your agency that involves at least three steps. Good candidates: creating a new SOP, building a client onboarding checklist, reorganizing a vault folder, or writing a content brief.

Step-by-step walkthrough

Choose a real task

Pick something from your current work. Do not invent a practice task — use something real. For this walkthrough, we will use: "Create a detailed client onboarding checklist that includes every step from initial contract signing through first month delivery."

If you have a different task, substitute it. The process is identical.

Enter plan mode and provide context

Start Claude Code on the VPS in your vault directory:

```
ssh vps
cd /root/vault
claude
```

Enter plan mode:

```
/plan

I need to create a comprehensive client onboarding checklist. It should cover every step from contract signing through the first month of service delivery. Use the vault notes as context — check the Client Onboarding SOP, the Service Stack, and any existing operational notes. Do not create anything yet — just plan.
```

Claude Code will read relevant vault notes and propose a plan. The plan should include:

• What files it will read for context
• What the checklist will contain (sections, steps, responsible parties)
• Where the checklist will be saved in the vault
• How you will verify the checklist is complete

Review the plan critically

Read the plan carefully. Ask yourself:

• Does the plan cover all the steps you actually do during onboarding? If your agency sends a welcome email, schedules a kickoff call, grants tool access, and creates reporting templates — are all of those in the plan?
• Is anything missing? Most plans miss at least one thing on the first draft.
• Is the scope right? The plan should not expand into "redesign the entire onboarding process." It should create a checklist based on how you currently do things.
• Is the file location correct? The checklist should go in the Operations folder based on your vault conventions.

Give feedback:

```
The plan is missing the step where we set up the client's Google Analytics access. Add that between "grant tool access" and "create reporting templates." Also, the checklist should include estimated time for each step so account managers can plan their day.
```

Claude Code updates the plan based on your feedback.

Approve and execute

When the plan looks right:

```
Plan looks good. Execute it.
```

Claude Code will work through the plan step by step. For each step that involves creating or modifying a file, you will see the permission prompt. Review the proposed content for each step.

During execution, if something does not look right, say so immediately:

```
Wait — that step should list the specific tools we give clients access to: Google Analytics, Google Search Console, and the GHL dashboard. Do not use a generic placeholder.
```

Claude Code adjusts and continues.

Verify the result

After execution is complete, run a structured verification:

```
The checklist is done. Now verify it against these criteria:

1. Every step from contract signing through first month delivery is included.
2. Each step has a clear action and responsible party.
3. Estimated times are included.
4. The file is saved in the Operations folder.
5. The file follows our vault naming conventions.
   Read the file and check each criterion.
   ```

Claude Code will read the finished checklist and evaluate it against your criteria. If anything fails, it will tell you what is missing.

Capture a lesson

Finally, update your Lessons Log:

```
Add an entry to the Lessons Log noting what we learned from this planning process. Specifically: [whatever you noticed — maybe the first plan was missing a critical step, or the scope needed adjustment, or the verification caught an error].
```

This lesson capture is what makes the system compound. The next time you plan a similar task, you (or Claude Code, if it reads the log) will avoid the same mistake.

Failure modes and verification checks

The main failure is rushing through plan review. If you approve a plan without reading it critically, you lose the primary benefit of plan mode. The second failure is not defining verification criteria — "looks good" is not verification.

Verification: the task was completed using the plan-execute-verify cycle. The plan was revised at least once based on your feedback. The verification step used explicit criteria. A lesson was captured.

Implementation checklist

• Choose a real multi-step task.
• Enter plan mode and provide context.
• Review the plan critically — identify at least one gap or improvement.
• Give feedback and get the plan revised.
• Approve and execute step by step.
• Interrupt execution if any step looks wrong.
• Run structured verification with explicit criteria.
• Capture a lesson in the Lessons Log.

Immediate next action

Move to the next module. Plan mode is now in your toolkit. You will use it whenever the work is complex enough to warrant it — and over time, you will get faster at both planning and verification.

Exercise

Run a second task through the full loop. This time, try something different from the first task — if you created a checklist, now build an SOP. If you wrote a document, now reorganize a folder. The point is to prove the loop works for different task types.

After completing the second task, compare the two experiences. Was the second plan faster to create? Did you catch issues earlier? Did the verification step find fewer problems? If the answer to any of those is yes, the loop is already compounding.