--- title: Rowan Starter subtitle: A free starter kit for running Claude Code as a thinking system, with every file laid out so you can read it before you run it. author: Rowan Advisory collection: Working Theory source: https://ip.rowanadvisory.co.nz/rowan-starter/ version: v2.6 · 4 Jul 2026 as_of: 4 July 2026 --- # Rowan Starter *A free starter kit for running Claude Code as a thinking system, with every file laid out so you can read it before you run it.* Free to take · MIT licensed. The frame behind it: [A verifiable core for one](https://ip.rowanadvisory.co.nz/verifiable-core-for-one/). ## What it does It gives your Claude Code three automatic habits and a helper, so the setup *remembers, improves, and never sends anything out* without your say-so, instead of starting cold every time. - **Starts every session pointed the right way.** Before you type anything, it reminds the system that your own notes are the source of truth, and to capture things as they happen rather than wait to be told. - **Ends every working session by learning.** When you stop, it pauses and asks itself: did anything worth keeping happen here? A decision, a changed fact, a new preference? If so, it offers to file it. If not, it just stops. So the setup gets a little sharper each time instead of forgetting. - **Asks before it sends anything out.** Before a publish (a `git push`), it pauses and asks you to confirm. Going public stays a human decision, never an automatic one. You generalise it to your own outward steps. - **Helps a newcomer build their own.** A short skill that walks someone from a blank setup to a lean, two-layer one. It only shows up when they're actually setting up. It's the difference between a tool you re-explain yourself to every morning, and a system that holds your context and quietly keeps it current. And because it's a plugin, you can hand all of that to someone else in a single folder. > It's a *seed* on purpose (v0.3). It carries the *shape* of the method, not anyone's personal voice. Take it, grow your own from here, and trade what works. ## Start right now, no terminal You don't need the plugin, or a terminal, to get the value. Open the Claude app and set up the one habit the kit automates: keep a short file of who you are and how you work, treat it as your source of truth, and read it at the start of every session. Ask Claude to draft that file with you. Paste it back each time you start. That's the core move; everything below just makes it run on its own. Want a scorecard first? The frame behind this, [A verifiable core for one](https://ip.rowanadvisory.co.nz/verifiable-core-for-one/), closes with nine checks. Paste them into any AI and it tells you where your setup stands and what to build next. No install, whatever tool you already use. ## The kit, in the open When you're ready for the automatic version, here's the whole thing in the open. A plugin in Claude Code is just a folder it knows how to load: a little config, the hooks, and a skill. Nothing is hidden or compiled. Read all of it in a couple of minutes, decide if you trust it, and only then install it. It's MIT licensed: take it, change it, ship it. **Get the files on GitHub:** [github.com/rachel-rowanadvisory/rowan-starter](https://github.com/rachel-rowanadvisory/rowan-starter) ## The whole folder ``` rowan-starter/ .claude-plugin/ plugin.json the ID card marketplace.json makes it installable in one command hooks/ hooks.json wires the three hooks on session-context.sh runs at session start session-reflect.sh runs at session end publish-guard.sh runs before a publish, asks first skills/substrate-setup/ SKILL.md the one skill README.md the human explanation LICENSE MIT ``` ## Every file **`.claude-plugin/plugin.json`** — the ID card. Name, version, one-line description. This is what makes the folder a plugin. ```json { "name": "rowan-starter", "version": "0.3.0", "description": "A working Claude Code setup, packaged. The lean-OS pattern + two self-improving hooks (start-load, stop-reflect) + a boundary guard that asks before you publish + one setup skill.", "author": { "name": "Rowan Advisory", "url": "https://rowanadvisory.co.nz" } } ``` **`hooks/hooks.json`** — switches the three hooks on, and tells Claude Code where to find them inside the plugin. ```json { "SessionStart": [ { "hooks": [ { "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/hooks/session-context.sh" } ] } ], "Stop": [ { "hooks": [ { "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/hooks/session-reflect.sh" } ] } ], "PreToolUse": [ { "matcher": "Bash", "hooks": [ { "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/hooks/publish-guard.sh" } ] } ] } ``` **`hooks/session-context.sh`** — runs once at the start of every session. Reminds the system to file durable learnings as they happen, so memory isn't left to chance. Edit the one message line to your own words. ```bash #!/bin/bash # SessionStart — load the right context every session, deterministically. today=$(date +%Y-%m-%d) ctx="Today is ${today}. File durable learnings (facts, decisions, preferences, state changes) into your memory/context layer as they occur, don't wait to be asked. Your context files are the source of truth; if anything conflicts, they win." /usr/bin/python3 - "$ctx" <<'PY' import json, sys print(json.dumps({"hookSpecificOutput": {"hookEventName": "SessionStart", "additionalContext": sys.argv[1]}})) PY exit 0 ``` **`hooks/session-reflect.sh`** — runs at session end. Reflects on what happened and proposes filing anything worth keeping. Two safety rails: it can't loop, and it fires at most once every 30 minutes so it's never a nag. It only proposes; you decide. ```bash #!/bin/bash # Stop — the self-improving half. Reflects once per working session. # Loop-guarded + debounced. It only PROPOSES. input=$(cat) # rail 1: if already in a reflection pass, stop (no loop) active=$(printf '%s' "$input" | /usr/bin/python3 -c \ 'import sys,json; print(json.load(sys.stdin).get("stop_hook_active", False))') if [ "$active" = "True" ]; then exit 0; fi # rail 2: fire at most once every 30 min (1800s) stamp="$HOME/.claude/.last-reflect-rowan" now=$(date +%s); last=0 [ -f "$stamp" ] && last=$(cat "$stamp" 2>/dev/null || echo 0) if [ $(( now - last )) -lt 1800 ]; then exit 0; fi echo "$now" > "$stamp" /usr/bin/python3 <<'PY' import json reason = ("Session reflection. Before ending: scan this session for anything DURABLE: a changed fact, a decision, a new preference, a state change worth keeping. If yes, file it now, then stop. If nothing durable changed, just stop, don't invent something.") print(json.dumps({"decision": "block", "reason": reason})) PY exit 0 ``` **`hooks/publish-guard.sh`** — runs before any Bash command. If the command would publish (a git push), it pauses and asks you to confirm, so going public is always your call. Generalise the pattern to your own outward steps: deploy, release, send. ```bash #!/bin/bash # PreToolUse(Bash) — the boundary guard. Ask before a command # that PUBLISHES. Generic by design; make it yours. input=$(cat) cmd=$(printf '%s' "$input" | /usr/bin/python3 -c \ 'import sys,json; print(json.load(sys.stdin).get("tool_input",{}).get("command",""))') case "$cmd" in *"git push"*) /usr/bin/python3 <<'PY' import json print(json.dumps({"hookSpecificOutput": { "hookEventName": "PreToolUse", "permissionDecision": "ask", "permissionDecisionReason": "This publishes (git push). Confirm you want to send it out. Publishing should be your call, not automatic."}})) PY exit 0 ;; esac exit 0 ``` **`skills/substrate-setup/SKILL.md`** — the one skill. It's a guided walk-through Claude runs for you: it asks a few questions, drafts your lean identity file with you, and writes it. You never open or edit a file yourself. Trimmed here to its spine. ``` --- name: substrate-setup --- # Substrate setup — a guided walk-through A conversation you run FOR the user: you ask, you draft, you write the files, you confirm. They never edit a file by hand. Run it one step at a time. Before you start Say what you'll build: one short "who I am, how I work" file Claude reads every session. Ask where it lives (default ~/.claude/CLAUDE.md). Don't stall on the choice. 1. Learn who they are Ask, plainly: what do you do · who do you serve · how do you like to be spoken to. Wait for answers. 2. Draft the always-loaded layer (keep it lean) who I am · how I work · what's protected. Show the draft, fix it together, write it only once they say it's right. Rule: if a fact doesn't change most answers, it does NOT go here. 3. The hooks already do their job Nothing to touch. Offer to reword the session-start line for them only if they want it. 4. The load-on-demand layer (when ready) deeper IP, projects, people, tools in a context/ folder the identity file points to. Pulled in only when its task comes up. Offer to stub it; don't fill it on day one. 5. Keeping it true overwrite the one file as it sharpens; keep a "what's retired" list. No stale second copy. Stop once the always-loaded file is right. That's the core. ``` **`README.md`** — the plain-English explanation that ships with the folder. What's in it, what it leaves out, how to install, and the licence. ## If you want to run it **New to Claude Code?** [Install it here first](https://code.claude.com/docs/en/setup). Then read the files above, and in Claude Code: 1. Add the marketplace: `/plugin marketplace add rachel-rowanadvisory/rowan-starter` 2. Install it: `/plugin install rowan-starter@rowan-starter`. The three hooks switch on at your next session; the skill appears only when you're setting up. 3. That's the working setup, no editing needed. When you want to make it yours, just ask Claude to reword the message in `session-context.sh` to your own voice. You never have to open the file yourself. You don't need to clone or download anything. The two commands above fetch it for you. The full source is on this page, and on [GitHub](https://github.com/rachel-rowanadvisory/rowan-starter) if you want to fork it. Once a setup works, you can hand the *shape* of it across in a folder this small, and the next person starts where you finished. --- *Rowan Advisory · free to take, MIT licensed. The repo: [github.com/rachel-rowanadvisory/rowan-starter](https://github.com/rachel-rowanadvisory/rowan-starter). A companion to the frame behind it: [A verifiable core for one](https://ip.rowanadvisory.co.nz/verifiable-core-for-one/).* --- *Working Theory · v2.6 · 4 Jul 2026 · ip.rowanadvisory.co.nz/rowan-starter/*