Vibe Code Camp

Roadmap

Select a workstream below, or walk to its plot. Dependencies are strictly sequential, as ratified by the Steering Committee.

What the world published lately

Loading the sources...

Sync with the template repo

The game and the terminal companion share one progress code. In the repo: uv run vibe export prints a code to paste here; uv run vibe import <code> takes the one from here and writes the vault notes.

Template repo (fork it with "Use this template"): github.com/tpetedb/vibe-map. It ships AGENTS.md, five skills in the Agent Skills standard, a subagent, a hook, the CLI, DuckDB queries and a starter vault. Setup: bash scripts/setup.sh.

Workstream 0

Pre-flight

Twenty minutes of unglamorous enablement so that the evening has zero blockers, zero dependencies and zero excuses.

Lesson: Pre-flight: set up the machine

Twenty minutes, alone, before the night. Everything here is boring on purpose so the evening itself is not.

1. Install Claude Code

Open Terminal (Cmd+Space, type Terminal). Paste this and press Enter. It installs the native build, which updates itself in the background:

curl -fsSL https://claude.ai/install.sh | bash

Then confirm it worked. It should print a version number followed by (Claude Code):

claude --version

2. Log in

Start it once. Your browser opens, you sign in with your Claude account (Pro, Max, Team or Enterprise), and the credentials are stored. You will not be asked again.

claude

Type /exit to leave. If you ever need to switch accounts, type /login inside a session.

3. Install git and jq

git is the save-point system for workstream 4, jq is a tiny helper the hook uses. On a Mac:

xcode-select --install
brew install jq

If brew is not installed, the first line still gives you git; ask Claude to install Homebrew for you on the night, it takes two minutes.

4. Install Obsidian

Download from obsidian.md, open it once, close it. Do not create anything yet.

5. Think of a game

One small game you would enjoy having on your laptop. A card duel, a dungeon room, a scoring board that ranks the team by coffee consumption. Three sentences, in your head.

Definition of doneTerminal shows a version for claude --version, and git --version prints something. That is the whole pre-flight.

Source: Claude Code quickstart, Obsidian

18:00, Workstream 1

The Innovation Hub

Pairing, 18:00Bourgogne Blanc, Chardonnay, unoaked, served at a disciplined 11°C. Rolinda's note, verbatim and in the original: "lekker arrogant aan de wang hangt en goed tegen de huig galoppeert." Accompanied by gougères, because shipping an MVP deserves warm cheese pastry, not a slide.

Before the first glass is empty we ship a minimum viable product to production. You articulate the north-star vision in a three-sentence elevator pitch. Tom imposes one non-negotiable guardrail: single-file architecture, no third-party dependencies, zero technical debt on day one. Then it exists. Time to value: sub ten minutes. Please update your priors accordingly.

No knowledge transfer takes place this hour. This is intentional. We front-load the quick win, socialise the outcome, and backload the target operating model into subsequent workstreams.

Your three sentences

What is it, who plays it, how do you win. Type them here and the prompt you paste into Claude Code is written out below, with Tom's guardrail already attached.

Lesson: Ship an MVP

The goal of this hour is one thing: a playable game exists before the first glass, or cup, is empty. We explain almost nothing. That is the design.

You need two things: a terminal, and Claude Code signed in. Pre-flight in the Roadmap installs both in twenty minutes.

Concept: the agentic loop

Claude Code is not a chat box. You give it a goal in plain language, it reads and writes files in the folder you started it in, runs commands, looks at the result, and keeps going until the goal is met. The folder you start it in is its whole world, so start it in an empty one.

Do this

Step into your workspace, the folder that is yours in the camp:

cd ~/vibe-map-*/workspace/game

Start Claude Code:

claude

On Pro and Max plans the session starts in auto mode: Claude edits files and runs most commands without asking each time, and a classifier reviews risky actions. Press Shift+Tab at any time to cycle to a mode that asks first. Tonight, auto is fine.
Say your three sentences out loud to Tom first. Then type them, with the one guardrail added. A template:

Build a small browser game as a single file called index.html, no external libraries, no frameworks. The game: [your three sentences]. Keep score. When done, tell me how to open it.

When it says it is done, open the file:

open index.html

Play it. Send it to someone. That is the OKR.

One more thing, then stop

Ask for exactly one change, in one sentence, and watch it land. Then leave it alone. The next hour is about why that worked or did not.

Definition of doneworkspace/game/index.html exists in your camp, it opens in a browser, and you can play it. If Claude asked a permission question you did not understand, answer yes and tell Tom; understanding permissions is workstream 4.

Why it mattersYou now know the loop: describe, wait, look, adjust. Everything after this is about making the loop reliable instead of lucky.

Try thisIf the first result is broken, do not fix it yourself. Paste the error, or describe what you see, and let it iterate. Say what is wrong, not how to fix it.

Source: Quickstart, How Claude Code works

19:00, Workstream 2

The Centre of Excellence

Provider-agnostic: AGENTS.md and the Agent Skills standard

Two open standards mean your rules are not locked to one vendor. AGENTS.md is a plain Markdown file at the repo root that 30+ coding agents read (Codex, Cursor, Copilot, Gemini CLI, Aider, Zed and more), stewarded by the Linux Foundation's Agentic AI Foundation: agents.md. Claude Code reads CLAUDE.md instead, so the template's CLAUDE.md is one line, @AGENTS.md, plus Claude-only extras: memory docs.

Agent Skills is the open format for skills: a folder with a SKILL.md (name, description, instructions), loaded only when relevant: agentskills.io. The cross-tool folder is .agents/skills/; Claude Code reads .claude/skills/, so the template symlinks one to the other. Community packs you can install into any agent: wshobson/agents.

Do this: open the template's AGENTS.md, change one rule to your taste, and watch Claude follow it next session.

Pairing, 19:00Same Chardonnay, now two degrees warmer and "opening up", which is Rolinda's way of saying the bottle has been on the table for an hour. Marcona almonds, lightly salted, to reward specificity. Vague prompts get the plain ones.

Tom asks you to make the MVP "more impactful". It regresses across every dimension of the scorecard. Then you raise one well-scoped, outcome-oriented change request with explicit in-scope and out-of-scope sections, and it lands first time, on time, on budget. Key learning for the lessons-learned log: the agent has zero line of sight into your mental model. Specificity is not a nice-to-have. Specificity is the deliverable.

Anything you catch yourself repeating gets codified into a skill: a living playbook the agent ingests automatically at every touchpoint, so you stop re-onboarding it session after session. Think of it as a standing operating procedure with executive sign-off.

The same change, asked for two ways

One component, two change requests. Press either and watch what the agent is free to touch.

Your first playbook

Edit freely. This is the standing operating procedure the agent reads at every touchpoint.

Lesson: Specificity, CLAUDE.md and your first skill

This is the hour that separates people who vibe code from people who got lucky once.

Concept 1: the model has no line of sight into your head

It only has what is in the folder and what you typed. "Make it more impactful" is a request it will fulfil according to its own idea of impact. "Add a badge next to the title, keep the colour and the columns, do not touch anything else" has a scope, a keep-list and a do-not-touch list. That is the entire craft.

Do this: break it, then fix it

Ask for the vague thing and watch what happens:

make it more impactful

Now ask for one precise thing. State what to add, what to keep, what not to touch:

Add a purple badge to the main character. Keep all stats and the score exactly as they are. Do not change anything else. Reply with one line describing what you changed.

Compare. The second one is a change request. The first was a mood.

Concept 2: CLAUDE.md, the note it reads every session

Every session starts with a blank memory. CLAUDE.md is a plain markdown file in your project folder that Claude reads at the start of every session. It is where you write down what you would otherwise re-explain: build commands, conventions, "always do X" rules. Target under 200 lines, concrete enough to verify. "Keep it one file" beats "keep it simple".

Let Claude draft one from what it sees in the folder:

/init

Then add your own rules. Ask Claude to add them, or open the file yourself with /memory. A good starting set:

# Rules for this project
- Single file: index.html only, no external libraries
- Readable on a laptop, minimum font size 14px
- Scores are a system of record: never reset or reformat stored scores without asking
- After every change, reply with one line saying what changed

Confirm it loaded. Start a new session and run:

/context

Your CLAUDE.md should be listed under Memory files. If it is not there, Claude cannot see it.

Concept 3: skills, procedures that load on demand

CLAUDE.md is for facts that apply every session. A skill is a folder with a SKILL.md for a repeatable procedure, loaded only when it is relevant or when you type /skill-name. Personal skills live in ~/.claude/skills/ and work in every project.

Create one for adding features to your game:

mkdir -p ~/.claude/skills/add-feature

Ask Claude to write ~/.claude/skills/add-feature/SKILL.md with this content, or paste it yourself:

---
description: Add a feature to the game safely. Use when the user asks to add, change or extend gameplay.
---

When adding a feature:
1. Restate the request in one sentence and list what will NOT change.
2. Make the change in index.html only.
3. Open index.html and check it still loads without console errors.
4. Reply with one line: what changed, and one sentence: what to test.

Use it:

/add-feature give the enemy a health bar

Or just ask normally. Claude loads it automatically when the description matches.

Bonus: auto memory

If you tell Claude "remember that I prefer British spelling", it saves that to its own notes for this project and loads them next time. Run /memory to see and edit everything it has saved. Everything is plain markdown you can delete.

Definition of done/context lists your CLAUDE.md. /add-feature appears when you type / in a session. A vague prompt now gets a clarifying question or a scoped change instead of a rewrite.

Why it mattersCLAUDE.md for what is always true, skills for how to do a thing, your prompt for what to do right now. Once those three are separated you stop re-onboarding the agent every evening.

Try thisRolinda's test: read your CLAUDE.md to her. Every line she can verify ("is it one file? yes/no") is a good line. Every line she has to interpret is a bad one.

Source: How Claude remembers your project, Skills, Best practices

20:00, Workstream 3

The Data Warehouse

Real tools: DuckDB SQL and a little Python

The template ships workspace/data/scores.csv, three DuckDB queries and one Python script, all tested. DuckDB reads a CSV as a table with no server: duckdb -c "select * from 'workspace/data/scores.csv' order by score desc limit 5". Docs: duckdb.org/docs. Zero-to-SQL in an evening: SQLBolt; analytics-flavoured: Mode SQL tutorial.

Do this, in order: duckdb < workspace/sql/top_runs.sql, then workspace/sql/per_player.sql (group by), then workspace/sql/streaks.sql (window functions, lag()). Then python3 workspace/python/scores.py and read the one new concept explained at the top of the file (a dict comprehension). Then ask Claude: "add a column to scores.csv and update every query that breaks". Python reference: the official tutorial; practice: Exercism, Kaggle Learn.

Pairing, 20:00Sancerre, Loire, mineral, "a chalky finish that lingers like an unresolved action item". Served with a chèvre plate arranged by ash content, ascending. Data has a schema; so does the cheese board.

The MVP pivots to a data-driven, insight-led, metrics-first posture. Every session is persisted to a file, which we will refer to as the enterprise data warehouse for the remainder of the evening. Then we surface actionable insights: top performers, rolling averages, streak analytics, all visualised on a self-serve dashboard. You will observe that the file rapidly becomes the single source of truth and the game a mere presentation layer.

Data requires a fixed location and a governed schema. Relocate the file, rename a column, and downstream dashboards are impacted, incidents are raised, and Tom is paged. This is the precise moment a folder graduates into a platform.

The column names are the contract

The same rows and the same query. Rename one column and watch every reader of the file go red.

Lesson: Persisted scores and a dashboard

Time to feed the spreadsheet person. The game learns to remember, the data gets a home, and the home turns out to matter more than the game.

Concept: a fixed home and a fixed shape

A browser page cannot write files to your disk on its own, so the pattern is: the game stores every finished round in the browser (localStorage), and offers an Export button that downloads a CSV. Once that CSV has a fixed name and fixed columns, anything can be built on top of it. Rename one column and everything downstream breaks. That is not a bug, that is what a schema is.

Do this

Add persistence with an explicit schema:

Every time a round ends, save a record to localStorage with exactly these fields: played_at (ISO timestamp), player (string), score (integer), duration_s (integer). Add an "Export CSV" button that downloads all records as scores.csv with those four columns in that order and a header row. Do not change gameplay.

Play three rounds, export, and move the file to the one place the check looks (from your camp folder):

mv ~/Downloads/scores.csv workspace/data/scores.csv
head -1 workspace/data/scores.csv

That header line must read played_at,player,score,duration_s, exactly. It is the same schema the camp's queries and uv run vibe check 3 expect.

Now ask for analysis on top of the file, not the game:

Write workspace/python/analyze.py that reads workspace/data/scores.csv, prints number of rounds, mean score, best score, longest streak of improving scores, and saves a bar chart of score per round to chart.png. Use only the Python standard library plus matplotlib. Then run it.

Open the chart:

open chart.png

Break the schema on purpose. Rename the score column in workspace/data/scores.csv to points, run analyze.py again, watch it fail. Rename it back.

What Lotte will notice

The game is now a front end. The CSV is the thing. Any spreadsheet, script or chart can read it, and Claude can build the next one in a minute because the shape is known. This is the same idea as a table in a database: the columns are a contract.

Definition of doneworkspace/data/scores.csv has the header row played_at,player,score,duration_s and at least three rows. There is a query in workspace/sql/ and a script in workspace/python/ that read it. uv run vibe check 3 is green.

Why it mattersEvery useful tool you build for work will be this pattern: something produces a file with a fixed shape, something else reads it. Meeting notes to action list, calendar export to weekly summary. Learn to name the columns first.

Try thisAdd a fifth column, difficulty, in both the game and the script, in one prompt. Notice you have to say both places, and that the check goes red until the header matches again.

Source: Common workflows

21:00, Workstream 4

The Business Continuity Tower

Pairing, 21:00Pivot to red. Barolo, Nebbiolo, decanted at 19:30 in anticipation of the Sev 1. Tannins "structured, almost bureaucratic". Cured meats, sliced thin enough to be auditable. Rollback pairs with a second glass.

Git, in two bullet points for the executive summary: a commit is a named, immutable, auditable snapshot, and rollback is always on the table. Tonight you ship a change, commit it, deliberately introduce a Sev 1 incident with full customer impact, and execute a controlled rollback within the agreed recovery time objective. Tom, as SRE, will be on call and will visibly age.

Then one hook: an automated control that fires at a defined lifecycle event, for example snapshotting the data warehouse after every edit. A hook is not guidance, a best practice, or a gentle nudge. A hook is enforcement. Compliance will be delighted.

Change management

Lesson: Git, rollback, and one hook

Fear of breaking things is what stops people from experimenting. This hour removes the fear.

Concept 1: commits are named snapshots

git keeps a history of your folder. A commit is a snapshot with a message. You can look at old ones, compare them, and go back. Claude Code makes this conversational, you never have to memorise commands.

Turn the folder into a repository and take the first snapshot:

initialise git in this folder, add a .gitignore that excludes backups/ and .DS_Store, and commit everything with the message "first playable"

Make a change (any feature), then:

commit my changes with a descriptive message

Look at the history:

show me the last 5 commits

Now break it on purpose. Ask for something destructive: "replace all text in the game with Comic Sans and remove the score". Confirm it is ruined.
Roll back:

discard all uncommitted changes and restore the last commit

Open index.html. It is fine again. Tom can stop pretending to be paged.

Concept 2: two undo buttons

Inside a session, Claude Code also keeps its own checkpoints: /rewind takes the files back to an earlier point in the conversation. That is for "the last ten minutes went wrong". git is for "I want this to survive closing the laptop". Use both.

Concept 3: hooks, things that happen every time

CLAUDE.md is advice. Claude reads it and tries. A hook is a shell command Claude Code runs at a fixed moment in its lifecycle, whether Claude wants to or not. PostToolUse fires after a tool ran, PreToolUse fires before and can block. Hooks live in a settings file, and the /hooks menu shows what is registered.

Create the project settings file. Ask Claude, or write .claude/settings.json yourself:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "mkdir -p backups && cp scores.csv backups/scores-$(date +%Y%m%d-%H%M%S).csv 2>/dev/null || true"
          }
        ]
      }
    ]
  }
}

The matcher means: only after the Edit or Write tools. The command copies scores.csv into backups/ with a timestamp, and the || true means a missing file does not count as an error.
Check it registered:

/hooks

Ask Claude to edit any file. Then look in backups/. A copy appeared without anyone asking for it.
The other kind: a hook that blocks. Ask Claude to add a PreToolUse hook that refuses any Edit or Write to scores.csv, exits with code 2 and prints a reason. Then ask it to edit scores.csv and watch it get refused and explain why.

Optional, if the evening allows

Put the folder somewhere other than the laptop: "create a private GitHub repository for this project and push it". Claude will ask you to sign in to GitHub the first time.

Definition of donegit log shows at least three commits. Ruining and restoring works. /hooks lists your PostToolUse hook and backups/ fills up when files change.

Why it mattersAdvice can be ignored, enforcement cannot. When something must happen every single time, it is a hook, not a sentence in CLAUDE.md. And with git underneath, no experiment is expensive.

Try thisAsk Claude to add a Notification hook that shows a macOS notification when it needs your input, so you can walk to the kitchen while it works.

Source: Hooks guide, Checkpointing and /rewind, Quickstart: git section

21:30, Workstream 5

The Stakeholder Alignment Bridge

Pairing, 21:30A Grüner Veltliner, "peppery, cross-functional", chosen because it goes with everything, much like an interoperability standard. Truffle crisps. Rolinda would like it noted that the truffle is real.

The chat window is not the enterprise perimeter. You integrate one system of record you already operate in, calendar, files or mail, and run a query that only works because of the integration. In Claude Code this is an MCP server. In the app it is a connector. Same underlying capability, different go-to-market. This is the workstream with the highest projected ROI, and the one most likely to quietly transform your Tuesday.

MCP in one sentence for the board pack: an open interoperability standard, so any tool plugs in the same way. Think USB-C, but for cross-functional enablement and ecosystem synergies.

Integration layer

Not integrated

Lesson: Connectors and MCP

Until now Claude could only see the folder. This hour it reaches your calendar, your files, your mail. This is the part that quietly changes a work week.

Concept: MCP is the plug

The Model Context Protocol is an open standard for giving an AI model tools. An MCP server is a program or a hosted service that exposes tools: search an issue tracker, read a calendar, drive a browser. Claude Code connects to servers; the Claude app calls the same thing connectors. Same idea, different door.

Do this: a server that needs no account

From your shell, not inside a session, add the Claude Code documentation server. The name claude-code-docs is one you choose:

claude mcp add --transport http claude-code-docs https://code.claude.com/docs/mcp

Check it connected:

claude mcp list

Start a session and force it through the new server so you can see it happen:

Use the claude-code-docs server to look up what a PostToolUse hook is

The tool call in the output is labelled with the server name. That label is how you know it went out, not from memory.

Scopes: where it is saved

By default the server is local: only you, only this project. Add --scope user to have it in every project, or --scope project to write it to .mcp.json in the folder so anyone who clones the project gets it too. Inside a session, /mcp shows the panel and lets you authenticate or reconnect.

Do this: something you actually use

Connectors you add at claude.ai (Settings, Connectors) load automatically in Claude Code when you are signed in with the same account. Connect Google Calendar or Google Drive there.
Or, for a hosted service with a sign-in, add it and authenticate in the /mcp panel:

claude mcp add --transport http notion https://mcp.notion.com/mcp
# then inside a session: /mcp → notion → Authenticate

Then ask something only the connection can answer:

What is on my calendar Thursday? Draft an agenda for the 10:00 as a markdown file called thursday-agenda.md

When done experimenting, unplug what you do not need. Every connected server uses some of Claude's context window:

claude mcp remove claude-code-docs

Definition of doneclaude mcp list shows at least one Connected server. A prompt that needs it produces a tool call labelled with the server name.

Why it mattersThe chat window is not the boundary. Once Claude can read the systems your work lives in, the tools you build stop being toys: a meeting note to action list, a week of calendar to a summary, a thread to three decisions.

Try thisRolinda's question, answered properly: it can only see what you connected, only while it is connected, and claude mcp remove unplugs it. Say that sentence back to her.

Source: Connect to MCP servers, MCP reference

22:00, Workstream 6

The Knowledge Management Tree

Pairing, 22:00Grower Champagne, zero dosage, "austere, honest, vendor-neutral". Dark chocolate at 72% because institutional knowledge deserves a proper finish. If this bottle is open, the retrospective can begin.

The final workstream has, by a distance, the best optics. You open Obsidian, point the agent at the vault, and have it document tonight's learnings, cross-link them, and tag them for discoverability. Then you open the graph view and watch institutional knowledge materialise in real time. Screenshots are encouraged for the all-hands.

Long-term memory is files with links. You own them, they are fully human-readable without any agent in the loop, they are vendor-neutral, and they compound quarter over quarter. This is your knowledge moat.

Knowledge capture

Below is a working vault: a live graph view of every note from tonight. Drag nodes, tap one to read it, follow the [[links]]. This is what your Obsidian will look like once Claude has written it for you.

Lesson: Obsidian and the graph

The last hour is the prettiest, and the one that gives everything before it a place to live.

Concept: a vault is a folder of markdown, links are just text

An Obsidian vault is a normal folder on disk. Every note is a .md file. A link from one note to another is the text [[Note name]]. The graph view draws a circle per note and a line per link; the more notes point at a note, the bigger it gets. Because it is all plain files, Claude can read and write the vault directly, and you can read it without any AI at all.

Do this

In Obsidian: bottom left, Vault profile, Manage vaults, Create new vault. Name it vibe-vault, put it in your home folder.
Start Claude Code inside the vault:

cd ~/vibe-vault && claude

Give it the conventions once, as a CLAUDE.md in the vault root:

Create CLAUDE.md with these rules: every note is markdown; link related notes with [[wikilinks]]; each note starts with a one-line summary; project notes live in Projects/, people in People/, tools in Tools/.

Now capture tonight:

Create Projects/Vibe Code Camp game.md summarising what we built tonight (single-file game, scores.csv schema, git, hooks). Create Tools/Claude Code.md, Tools/CLAUDE.md and skills.md, Tools/Hooks.md, Tools/MCP.md, Tools/Obsidian.md, each with a short explanation in my words and a "how to" section. Create People/Tom.md and People/Rolinda.md. Link everything that is related with [[wikilinks]] and make sure every note links to at least two others.

Open the graph: click the graph icon in the left ribbon, or Cmd+P and type "graph". Hover a node to highlight its links. Click one to open it.
Local graph: with a note open, Cmd+P, "Open local graph", to see only what connects to that note.
Colour it: graph settings (cog top right), Groups, New group, search path:Tools, pick a colour. Do the same for Projects and People.

This is your long-term memory

Next week, when Lotte builds the meeting-note tool, she starts Claude Code in the vault, and it can read Tools/Hooks.md to remember how she likes hooks written. Every project adds notes, every note adds links, the graph grows. Nothing is locked in: it is a folder of text files she owns. Put the vault in git too, and ignore the .obsidian folder.

Definition of doneThe graph shows at least ten nodes in three colours, and clicking any node opens a note Claude wrote that reads like Lotte, not like a manual.

Why it mattersMemory is files with links. You own it, it compounds, and both you and the agent can read it. That is the whole knowledge moat, and it cost one prompt.

Try thisAsk Claude, inside the vault: "what did we decide about scores?" and watch it find the answer by reading the notes, not by remembering.

Source: Obsidian: graph view, Obsidian: internal links, Obsidian: manage vaults

22:30, Workstream 7

The Go-to-Market Tower

Pairing, 22:30Tokaji Aszú, 5 puttonyos, "sweet, but earned", with Roquefort. Rolinda notes that a launch without dessert wine is a soft launch.

The MVP has lived on one laptop all evening. That is a single point of failure and, frankly, a governance risk. This workstream takes it public: the folder goes to GitHub, GitHub Pages serves it, and the game gets a URL you can send to anyone. Time to market: fifteen minutes, including the Roquefort.

Concept. A remote is a copy of your [[Git]] history on someone else's computer. GitHub Pages is a static host that serves the files in a repository as a website, which is exactly what a single-file game is. No server, no build step, no ops. Claude Code can do every step of this from the terminal.

Lesson: A URL you can send

Do this

Create a free GitHub account if you do not have one, then install and sign in to the GitHub CLI:

brew install gh
gh auth login

In Claude Code, from your camp folder:

create a public GitHub repo called vibe from this folder and push it

Then turn the pages on:

enable GitHub Pages for this repo from the main branch, root folder, and tell me the URL

If Claude cannot flip the setting, do it yourself in the repo's Settings, Pages tab. Then check the URL answers:

gh browse

Open the URL on your phone. Send it to someone who was not here tonight.

Definition of doneThe game loads on a device that is not your laptop, from a URL you did not have this morning.

Docs: GitHub Pages quickstart · gh repo create · Claude Code common workflows (git)

23:00, Workstream 8

The Autonomous Operations Plant

Pairing, 23:00Armagnac, 1998, in the small glasses. No food. Rolinda has called last orders and is prepared to enforce it.

Everything so far needed you at the keyboard. The final workstream removes you from the loop: Claude runs headless, on a schedule, does one job, and writes the result into your vault. This is the SRE hour. Tom is visibly moved.

Concept. claude -p "prompt" runs Claude Code without the interactive session: it takes the prompt, does the work in the folder, prints the result and exits. Put that in a scheduled job and you have an agent that runs while you sleep. A subagent is a second Claude the first one delegates to, with its own instructions, useful for a job you want done the same way every time.

Lesson: Headless, on a schedule

Do this

Try it once by hand, from your camp folder:

claude -p "read workspace/data/scores.csv and append a one-paragraph summary of tonight's best runs to vault/Camp/Scores.md"

Turn the job into a subagent that always does it the same way:

create a subagent called scorekeeper that only does that job, and document it in the vault

Put it on a clock (on a Mac). Read the plist it writes: it should call claude -p with --output-format text.

schedule the scorekeeper to run every morning at 08:00 with launchd

Check the job is loaded:

launchctl list | grep scorekeeper

Tomorrow morning: open the vault. The note updated itself.

Definition of doneA note in your vault changed without you touching the keyboard.

Docs: Run Claude Code programmatically (headless) · Subagents · CLI reference

Final slide

Calendar alignment

Beverage stack, go-liveRolinda has pre-approved the following: Bourgogne Chardonnay to open, Sancerre with the data, Barolo for the incident, Grüner for the integrations, Champagne for the graph, Tokaji for the launch, Armagnac for last orders. Anything else requires a change request and a decanter.

Eight OKRs unlocked, eight capabilities stood up, zero Sev 1s outstanding, the campus is fully operational and the Steering Committee has been briefed. The only open action item on the tracker is the go-live date. Tom has the following availability, subject to change control.

Go-live date

Beverage stack (Rolinda has veto)

Lesson: After the evening

Three things, in order, each one evening or less.

Build one boring tool for work: a messy meeting note pasted in, a clean action list out. Start in a new folder, write CLAUDE.md first, then ask.
Give it a file with a fixed shape and a chart, like workstream 3. Calendar export to a weekly summary is a good one.
Write the note about it in the vault, link it to Tools notes, look at the graph grow.

Tom is available for one panicked message per week. Rolinda is available for wine.

Supporting documentation, runbooks and enablement material for any workstreams deferred beyond the session window: the syllabus.