A typical day with the operator stack

Lesson outcome

You will have a clear daily workflow that uses the operator stack systematically, not randomly.

Why this matters in an agency

Tools without habits are shelfware. You can have Claude Code installed, a vault full of notes, and qmd configured — and still revert to doing everything manually because you never built the routine. This lesson defines the routine. Once you follow it for two weeks, it becomes automatic.

Inputs, tools, and prerequisites

The full operator stack working: Claude Code on VPS, vault with notes, BWS with credentials, CLAUDE.md, qmd. Real agency work to do today.

Step-by-step walkthrough

Morning: Orient

Open your terminal and SSH into the VPS:

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

Start with orientation. Ask Claude Code:

```
Read my Current Priorities note and my most recent journal entry. What should I focus on today?
```

Claude Code reads the vault notes and summarizes your priorities. If the priorities have changed since the last journal entry, update the Current Priorities note now.

Check for anything urgent:

```
Search the vault for any notes that mention deadlines this week.
```

This gives you a quick scan of upcoming commitments.

Work blocks: Execute

For each task in your day, decide: direct instruction or plan mode?

Simple tasks — direct instructions:

```
Add a journal entry for today. Note that I am focusing on [main task] and need to follow up with [client name] about [topic].
```

```
Update the Active Client Index — ABC Paving's monthly spend is now $3,200.
```

Complex tasks — plan mode:

```
/plan

I need to create a content brief for Summit Garage Doors' blog. They want to rank for "garage door repair [their city]." Use the vault notes on their services and our content production SOP to plan the brief. Do not write it yet.
```

Review the plan, adjust, execute, verify.

Retrieval when you need context:

When a question comes up mid-task, use qmd:

```
Use qmd to find any notes about our SEO pricing for garage door companies. I need this for a client proposal I am drafting.
```

Pull the relevant notes, use the information, continue working. No folder browsing, no guessing.

Afternoon: Build and verify

If you are building tools or scripts, use the VPS:

```
I want to modify the report generator to add a new section for SEO metrics: organic traffic, keyword rankings, and backlinks. The data will come from a new CSV column. Plan the changes before making them.
```

Use plan mode for any tool modifications. Verify after every change.

End of day: Update and capture

Before you stop working, update the vault:

```
Create today's journal entry with:

• What I accomplished: [list main outputs]
• What is pending: [list items not finished]
• Key decisions made: [list any decisions]
• Lesson learned: [if any]
  Add any lessons to the Lessons Log.
  ```

If any vault notes are outdated based on today's work, update them:

```
The Client Onboarding SOP should now include a step about sending the welcome email within 2 hours of contract signing. Update it.
```

Sync the vault to your local machine if you made changes on the VPS:

```
rsync -avz --include='/' --include='.md' --exclude='*' vps:/root/vault/ ~/Documents/AgencyVault/
```

Weekly: Review and improve

Once a week, spend 20 minutes on system maintenance:

```
Review the Lessons Log. Are there patterns? Are we making the same mistakes? If so, add a rule to CLAUDE.md to prevent them.
```

```
Search for notes that have not been updated in over a month. Are any outdated?
```

```
Check the vault structure. Are any folders getting too crowded? Should anything be reorganized?
```

These weekly reviews are what keep the system healthy as it grows.

Failure modes and verification checks

The main failure is not doing the morning orientation. If you skip it, you work reactively instead of proactively. The second failure is not capturing lessons at end of day — the system stops compounding.

Verification: after one week of following the workflow, check your journal entries. Do they show a pattern of orient → execute → capture? Are lessons being added to the log? Is the vault growing with real content? If all three are yes, the workflow is working.

Implementation checklist

• Morning: SSH in, orient with vault notes, check priorities.
• Work blocks: direct instruction for simple tasks, plan mode for complex ones.
• Retrieval: use qmd when you need context mid-task.
• Building: use plan mode for tool modifications and new builds.
• End of day: journal entry, lesson capture, vault updates.
• Weekly: review lessons, check for outdated notes, maintain structure.

Immediate next action

Follow this workflow starting tomorrow. Do not wait. The first day will feel slow. By day five, it will feel natural. By day ten, you will not want to work without it.

Exercise

Write your own version of the daily workflow, customized for your schedule. When do you start work? What are your typical first tasks? When do client calls happen? When do you do deep work? Map the operator stack workflow onto your actual day, not a generic template. Save it as a note in your vault called "My Operator Workflow." This note becomes part of the system it describes.