Pt 1 Harness Dev: Online Swapmeet

Configure a governed Claude Code agent and plan a feature with Plan Mode.

Introduction

30 Second Summary

AI coding assistants can write code fast. But without clear rules about what they should and shouldn't do, they produce inconsistent, hard-to-trust results. The difference between a helpful assistant and a reliable team member is the harness: the persona, guardrails, and skills that shape how the agent operates.

In this project, you will configure Claude Code as a governed coding agent with a custom persona and skills, point it at a real classifieds marketplace app, and use Plan Mode to decompose a feature into parallel development lanes ready for execution.

Swapmeet will be you're custom Craigslist. Harness engineering will be our devOps, but we'll continue to have many Parts, that will grow your Fullstack and Product skills delivering weekly features to your own custom Swapmeet.

What You'll Build

You will open a fresh terminal session, be greeted by name from an agent that knows its own rules, and have a feature decomposition pushed to GitHub that any team member or coordinator agent could pick up and start building from immediately.

By the end of this project, you'll have:

A personal Claude Code persona that persists across all your projects and greets you in-character every session.
A custom /til skill you can invoke to log learnings, proving the skill mechanism works before building anything complex.
A running SwapMeet classifieds app where every API request is logged to the terminal, with an agent that cites its own guards when asked what rules it follows.
A Plan Mode-derived implementation document pushed to GitHub that decomposes a feature into 2 independent dev lanes with exclusive file ownership and an explicit interface contract.
Secret Mission: Create a /wip-pr skill that enforces each lane to open a WIP PR branch and commit small code changes.

Are there any prerequisites?

You will need Node.js 18+ installed, Git installed, a GitHub account, and an active Claude subscription or API key.

You do not need prior experience with Claude Code. Step 1 walks you through installing and authenticating the CLI from scratch.

Before We Start

Before we dive in, let's lock in what you're about to build and why it matters. This project is about the harness around an AI agent. The persona, guards, and skills you give the agent shape its behavior far more than the underlying model.

Install Claude Code

Claude Code is a command-line tool that turns an AI model into a governed coding agent. It reads your project files, follows instructions you configure, and executes commands in your terminal.

Without it installed, the harness you build in this project has nowhere to live. In this step, you will install the CLI, authenticate, and confirm the interactive prompt launches cleanly.

In this step, get ready to:

Install the Claude Code CLI on your machine.
Authenticate with your Claude subscription or API key.
Confirm the interactive prompt opens without errors.

Install the Claude Code CLI

Claude Code ships as a standalone binary you install from your terminal. The install command differs by operating system.

Open your terminal. Press Cmd+Space (macOS) or the Windows key (Windows) to open your search bar.
Type Terminal (macOS) or PowerShell (Windows) and press Enter to open it.
Run the install script for your platform:

macOS

Install Claude Code by running this command:

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

What does this command do?

This downloads the official install script from Anthropic and pipes it to bash to execute. It places the claude binary in ~/.local/bin/ and sets up auto-updates.

Windows

Install Claude Code by running this command in PowerShell:

irm https://claude.ai/install.ps1 | iex

What does this command do?

This downloads the official PowerShell install script from Anthropic and executes it. It places the claude binary in your user path and sets up auto-updates.

Make sure your terminal prompt starts with PS (e.g. PS C:\>). If it shows just C:\> without PS, you are in CMD and need to switch to PowerShell.

Before you run the version check, what do you think the output will look like?

Verify the install succeeded by running:

claude --version

✔️ I see a version number like 2.1.x (Claude Code)

Claude Code is installed and ready. Move on to the next substep.

ⓧ I see an older version

Run the install command again. Native installations overwrite the previous version automatically.
Run claude --version again to confirm it updated.

ⓧ Command not found

Close your terminal and open a new one. The installer adds claude to your PATH, but an existing session may not pick it up until restarted.
Run claude --version again in the fresh terminal.
If it still fails, visit the Troubleshoot installation page on the Anthropic docs.

Authenticate Claude Code

Claude Code needs to connect to your Anthropic account to run. The first time you launch it, a browser window opens for login.

Start a Claude Code session by running:

claude

What happens when you run this?

If you have a Claude subscription (Pro, Max, Team, or Enterprise), a browser window opens asking you to approve the connection. Click Approve to link your account.

If you have the ANTHROPIC_API_KEY environment variable set instead, Claude Code skips the browser and asks you to approve the key directly in the terminal.

Complete the browser login flow by clicking Approve when prompted. If you are using an API key, type y to approve it in the terminal.

Browser didn't open?

If the browser does not open automatically, check your terminal output for a URL you can copy and paste into your browser manually.

If authentication keeps failing, make sure you have a paid Claude subscription (Pro, Max, Team, or Enterprise). The free Claude.ai plan does not include Claude Code access.

Still stuck? Help me troubleshoot my Claude Code authentication

Confirm the interactive prompt works

Once authentication succeeds, Claude Code drops you into an interactive prompt where you can type messages to the agent.

Look at your terminal. You should see the Claude Code interactive prompt ready for input, with no error messages above it.
Type a quick test message to confirm the agent responds:

Say hello in one sentence.

Confirm that Claude responds with a greeting. This proves the CLI is installed, authenticated, and talking to the model.
Exit the session by pressing Ctrl+C or typing /exit.

Seeing a permission or network error?

Make sure you have an active internet connection. Claude Code requires network access to communicate with the Anthropic API.

If you see a message about your account type, confirm you are on a paid Claude plan (Pro, Max, Team, or Enterprise).

Need more help? Help me debug my Claude Code connection

Your agent runtime is live. Next up, you will give this agent a personality and its first custom skill.

Give Your Agent a Persona and First Skill

Claude Code is installed and authenticated. You have a working agent runtime. Right now, though, every session starts the same way: generic, with no memory of who it is working with or what workflow you prefer.

In this step, you will give your agent a persistent persona and a custom skill. The persona loads automatically in every session across all your projects. The skill gives you a slash command you can invoke anytime to log what you learned.

In this step, get ready to:

Create a personal persona file that shapes every Claude Code session.
Build a /til skill that logs your learnings on command.
Verify both load correctly in a fresh session.

Create your personal persona file

Claude Code looks for a file at ~/.claude/CLAUDE.md every time it starts a session. Whatever you write in this file becomes part of the agent's instructions across all your projects automatically.

Create the persona file by running this command in your terminal:

mkdir -p ~/.claude
cat > ~/.claude/CLAUDE.md << 'EOF'
# Personal Persona

I am your coding partner. Greet every session with a short, friendly hello.

## Working style

- Lead with outcomes: say what you did and what proves it works.
- When blocked, say precisely what you need and from whom.
- Prefer the smallest change that delivers the goal.
EOF

What does this file do?

The # Personal Persona heading and greeting instruction tell Claude Code to say hello at the start of every session. This is your first proof that the harness shapes behavior.

The ## Working style bullets define how the agent communicates. It will lead with outcomes, be precise about blockers, and prefer small changes. These rules apply in every project you open.

Confirm the file was created by running:

cat ~/.claude/CLAUDE.md

You should see the full persona content printed back in your terminal, starting with # Personal Persona.

Seeing "No such file or directory"?

Make sure you ran the mkdir -p ~/.claude line as part of the command. If you pasted only the cat > portion, the directory may not exist yet.

help me troubleshoot why my ~/.claude/CLAUDE.md file was not created

✔️ Awesome, I've got everything!

Great. Make sure you have saved your file and move on to building your first skill.

ⓧ I'd like to double check the full code

Your ~/.claude/CLAUDE.md should contain exactly this:

# Personal Persona

I am your coding partner. Greet every session with a short, friendly hello.

## Working style

- Lead with outcomes: say what you did and what proves it works.
- When blocked, say precisely what you need and from whom.
- Prefer the smallest change that delivers the goal.

Create the /til skill

Skills are reusable slash commands that live in ~/.claude/skills/. Each skill gets its own folder, and the folder name becomes the command. A file called SKILL.md inside that folder defines what the skill does using YAML frontmatter and markdown instructions.

Create the /til skill by running this command:

mkdir -p ~/.claude/skills/til
cat > ~/.claude/skills/til/SKILL.md << 'EOF'
---
description: Logs a "today I learned" entry. Use when the user says they learned something, asks to note a learning, or invokes /til directly.
---

## Instructions

When invoked, format the user's learning as a concise TIL entry:

**TIL:** [one-sentence summary of what was learned]

**Context:** [brief note on where/how this came up]

**Why it matters:** [one line on when this knowledge is useful next]

If no learning is provided, ask "What did you learn?" and wait for a response.
EOF

What does this skill do?

The --- markers wrap YAML frontmatter. The description field tells Claude Code when to activate this skill. Because the folder is named til, you invoke it with /til in any session.

The ## Instructions section is a template the agent follows. It formats your learning into three parts: what you learned, where it came up, and why it matters next time.

Confirm the skill file exists by running:

cat ~/.claude/skills/til/SKILL.md

You should see the full YAML frontmatter and instructions printed in your terminal, starting with the --- delimiter.

File is empty or missing?

Check that you included the mkdir -p ~/.claude/skills/til line before the cat > command. The entire block must be pasted together as one command.

help me figure out why my /til skill file was not created correctly

✔️ Awesome, I've got everything!

Great. Time to prove both the persona and the skill actually load.

ⓧ I'd like to double check the full code

Your ~/.claude/skills/til/SKILL.md should contain exactly this:

---
description: Logs a "today I learned" entry. Use when the user says they learned something, asks to note a learning, or invokes /til directly.
---

## Instructions

When invoked, format the user's learning as a concise TIL entry:

**TIL:** [one-sentence summary of what was learned]

**Context:** [brief note on where/how this came up]

**Why it matters:** [one line on when this knowledge is useful next]

If no learning is provided, ask "What did you learn?" and wait for a response.

Verify the harness loads in a fresh session

Both files are in place. The real test is whether Claude Code picks them up automatically when you start a new session.

Before you run the next command, think about what you expect to see. If the persona loaded correctly, what should the agent's very first message be?

Start a fresh Claude Code session by running:

claude

The agent should greet you with a short, friendly hello without you prompting it. This is your persona in action.

Now test the skill. Type this directly into the Claude Code session:

/til I learned that CLAUDE.md files load automatically into every Claude Code session

The agent should respond with a formatted TIL entry containing a summary, context, and a "why it matters" line.

What just happened?

You proved two things. First, ~/.claude/CLAUDE.md loads silently into every session and shapes the agent's behavior from the first message. Second, the /til skill activates on demand and follows your template.

This is the core harness pattern: you define the rules once, and the agent follows them every time without reminders.

🙋‍♀️ No greeting or /til not recognized?

If the agent starts without a greeting, run cat ~/.claude/CLAUDE.md in a separate terminal to confirm the file has content. An empty file produces no greeting.

If /til is not recognized, check that the file is at exactly ~/.claude/skills/til/SKILL.md (not ~/.claude/skill/til/SKILL.md or another path). The directory name must be skills (plural).

help me debug why my Claude Code persona or /til skill is not loading

Your agent now has a persistent identity and a skill it carries into every project. Next up, you will point this governed agent at a real codebase and see how the harness interacts with project-level instructions.

Clone and Run SwapMeet

Your agent has a persona, a greeting, and a skill. Now it needs a real codebase to operate on.

SwapMeet is a classifieds marketplace app that ships working-but-ugly on purpose. The landing page renders raw JSON from the API instead of a polished UI. Seeing this baseline is the motivation for the feature work you will plan in Step 5.

In this step, get ready to:

Fork and clone the SwapMeet repo from GitHub.
Install dependencies for both the server and client using npm workspaces.
Run the dev servers and confirm the ugly baseline in your browser.

Fork and clone SwapMeet

SwapMeet lives on GitHub as a public repo. You will fork it to your own account so you can push changes later.

Open the SwapMeet repo in your browser:
https://github.com/Octonions-ai/swapmeet
Click the Fork button in the top-right corner of the page.
Leave the defaults and click Create fork.

Once the fork is created, you will be on your own copy of the repo. The URL in your browser now shows your GitHub username instead of Octonions-ai.

Click the green Code button and copy the HTTPS URL. You will need this in a moment.

Now clone the fork to your local machine.

Move to your Desktop by running this command:

cd ~/Desktop

Clone your fork by running this command (paste the URL you copied from GitHub):

git clone [[YOUR_FORK_URL="https://github.com/YOUR-USERNAME/swapmeet.git"]]

Move into the cloned repo by running:

cd swapmeet

Confirm the repo structure exists by running:

ls

You should see folders like server/, client/, data/, and guards/ alongside files like CLAUDE.md and package.json.

Don't see those folders?

Make sure you ran cd swapmeet after cloning. If you see a permission error on clone, confirm that you forked the repo (not just copied the URL from the original).

help me troubleshoot my git clone

Install dependencies with npm workspaces

SwapMeet uses npm workspaces. A single install from the repo root handles dependencies for both the Fastify server and the React + Vite client.

Install all dependencies by running this command from the swapmeet folder:

npm install

You should see npm resolve and install packages for both workspaces. The output ends with a summary of added packages.

What are npm workspaces?

Workspaces let a single package.json at the repo root manage multiple sub-projects (in this case server/ and client/). One npm install from the root installs everything, and scripts like npm run dev can start both services together.

🙋‍♀️ Seeing permission or network errors?

Check that you are inside the swapmeet directory (not one level above). If you see EACCES errors on macOS, try running the install without sudo and fix npm permissions instead.

help me fix npm install errors

Start the dev servers and confirm the baseline

SwapMeet uses the concurrently package to run both the API server and the client dev server with a single command.

Start both dev servers by running:

npm run dev

What does this start?

This command launches two processes at once. The Fastify API server starts on port 3001 (with Node's --watch flag for auto-restart). The Vite dev server starts on port 5173 and proxies /api requests to the Fastify server automatically.

This terminal is now occupied by the running servers. Leave it running for the rest of this project.

You should see output in your terminal showing both servers have started. Look for lines indicating the server is listening on port 3001 and the Vite client is ready on port 5173.

Before you open the browser, what do you think the landing page looks like? The repo ships "working-but-ugly" on purpose.

Open your browser and navigate to:

http://localhost:5173

You should see a heading, a listing count (8 listings), and a raw JSON dump of all the listing data. No cards, no grid, no styling. Just a <pre> tag full of JSON.

Switch back to the terminal where npm run dev is running.
Check the server output for Fastify request logs. Every time the browser fetched data, the server logged the request.

Why does it look so ugly?

This is intentional. SwapMeet ships with the App.jsx component dumping raw JSON via JSON.stringify. The "before" state gives you and your agent a clear target: turn this raw data into a real Listings Page. That is the feature you will plan in Step 5.

🙋‍♀️ Page not loading?

Make sure both servers are still running in your terminal. If you see an error about port 5173 being in use, close any other Vite dev servers. If the page loads but shows a blank screen, open DevTools (Cmd+Option+I on macOS, Ctrl+Shift+I on Windows) and check the Console tab for errors.

help me get SwapMeet running locally

Your harness now has a real codebase to work with. Next up, you will verify that the SwapMeet guards actually load into the agent and shape its behavior.

Tour the Agent Guards

SwapMeet is running and the ugly baseline proves the codebase works. But the agent that will improve it needs more than a personality. It needs rules it cannot break.

The persona you created earlier defines who the agent is. Guards define what it must never do. Without verifying the guards load correctly, you cannot trust the agent to follow scope ownership or log-driven validation when you enter Plan Mode in the next step.

In this step, get ready to:

Read the repo's guard files to understand the 5 core rules and 3 working-style defaults.
Verify the agent cites its guards unprompted when asked about its rules.
Test the guard boundary by asking the agent to propose landing page improvements.

Read the repo's CLAUDE.md and guard files

The SwapMeet repo ships its own CLAUDE.md at the project root. This project-level file defines the agent's identity for this repo specifically, and it references guard files using the @ import syntax.

Open a new terminal tab or window (your current terminal is running npm run dev).
Navigate to your SwapMeet directory by running:

cd ~/Desktop/swapmeet

View the project CLAUDE.md by running:

cat CLAUDE.md

You should see a file that identifies the agent as Johnny8, a Staff Engineer. Near the top, look for the Guards section referencing two files.

What is the @ import syntax?

Claude Code's CLAUDE.md files support @path/to/file syntax to import other files. When Claude Code loads the project's CLAUDE.md, it also reads any files referenced this way. Relative paths resolve relative to the file containing the import.

This means the guards in guards/core.md and guards/basic.md are automatically loaded into every Claude Code session you start inside this repo.

View the core guards by running:

cat guards/core.md

You should see 5 non-negotiable rules that any agent working in this repo must follow.

What are the 5 core guards?

Log-driven validation — a change is not done because the code looks right. It is done when you have observed it working via logs or a test run.
Scope ownership — only create or modify files inside your assigned scope. If the fix lives outside your lane, raise it on the Issue.
Contracts before code — shared shapes (JSON payloads, endpoints) are agreed before implementation starts. Never silently redefine an interface.
Traceable commits — every commit references its Issue, commits are small, and each leaves the app runnable.
Destructive actions need a human — deletes, force-pushes, and major-version bumps require explicit human approval first.

View the basic guards by running:

cat guards/basic.md

You should see 3 sections covering communication style, workflow habits, and quality bar expectations.

What do the basic guards cover?

Communication — lead with outcomes, surface surprises, and state blockers precisely.
Workflow — read before you write, plan before you build, prefer the smallest change, and run the app after every meaningful edit.
Quality bar — match surrounding code style, handle failure paths, and leave the app runnable at every commit.

These are lighter than core guards. They shape how the agent works rather than defining hard boundaries it cannot cross.

Verify the agent loads the guards

Reading the files tells you what the guards say. Now you need to confirm the agent actually internalizes them when you start a session inside this repo.

Start a Claude Code session inside the SwapMeet directory by running:

claude

The agent should greet you. You may see both your personal persona greeting and Johnny8's "Strength and honor" since both CLAUDE.md files load together.

Before you ask the next question, think: will the agent know the guards from this repo, or will it only know about your personal persona from ~/.claude/CLAUDE.md?

Type this question into the Claude Code prompt:

What rules do you operate under in this project?

The agent cites the core guards by name without you hinting at them: log-driven validation, scope ownership, contracts before code, traceable commits, and destructive actions need a human.

Why does this matter?

The agent read the project CLAUDE.md, followed the @ imports to both guard files, and internalized all 5 core rules plus the basic defaults. This proves the harness is loaded. Any time you start a session in this repo, the agent operates under these constraints automatically.

🙋‍♀️ Agent didn't mention the guards?

Make sure you started claude from inside the swapmeet directory, not from a parent folder. The project CLAUDE.md only loads when the session starts in or below the repo root.
Confirm CLAUDE.md exists at the repo root by running ls CLAUDE.md from the swapmeet directory.
Try exiting the session (type /exit) and starting again with claude.

Help me figure out why Claude Code isn't loading my project CLAUDE.md

Test the log-driven validation guard in action

Knowing the agent can recite its rules is one thing. Seeing those rules constrain its behavior is another.

In the same Claude Code session, type this prompt:

Describe what you would do to improve the landing page. Walk me through your approach.

Watch the agent's response carefully. It proposes changes (replacing the raw JSON with a card grid, adding styling), but it does not claim any of those changes work. It says it would need to run the app and observe the server logs to validate each change.

What just happened?

This is guard #1 (log-driven validation) in action. The agent cannot say "done" without citing evidence from logs or a test run. Even when describing a hypothetical improvement plan, it builds the validation step into its approach.

This constraint means the agent will never claim a feature works just because the code compiles. It will insist on running the app and showing you proof.

The harness is verified. Your agent knows its persona, follows its guards, and loads both automatically for every session in this repo. Next up, you will put the agent into Plan Mode and use it to decompose a real feature into independent dev lanes.

Plan Mode Decomposition

In the previous step you confirmed that the guards are loaded and active. The agent knows its rules. Now it is time to put the harness to work on a real feature.

If you asked the agent to "fix the landing page" right now in default mode, it would produce a single monolithic change touching both the server and client at once. That defeats the whole point of scope ownership. Plan Mode forces the agent to read the codebase first, then propose a structured decomposition before any edits hit disk. This is the core harness pattern: contracts before code.

In this step, get ready to:

Enter Plan Mode and prompt the agent to decompose the Listings Page v1 feature into 2 independent dev lanes.
Iterate on the plan until it specifies exclusive file ownership and an interface contract, then write it to implementation.md.
Commit and push implementation.md to your GitHub fork.

Enter Plan Mode and prompt the decomposition

Plan Mode is a read-only permission mode. The agent can explore files and propose a plan, but it cannot make edits until you approve and switch back to default mode.

Switch to your Claude Code session inside the SwapMeet repo from earlier.
Press Shift+Tab twice to cycle through modes (default to acceptEdits to plan). You will see the mode indicator change to ⏸ plan mode on.

Start directly in Plan Mode

If you prefer, start a fresh session already in plan mode by running:

claude --permission-mode plan

This skips the Shift+Tab cycling entirely.

Give the agent this prompt (paste or type it into the Claude Code input):

Analyze this repo and propose turning the landing page into a real Listings Page v1. Decompose the work into 2 independent dev lanes:

1. Server lane: add query params (category filter) and a categories endpoint
2. Client lane: card grid UI with category filter bar

Each lane must have exclusive file ownership (no shared files). Define an explicit interface contract: the exact endpoint paths and JSON response shape the client expects from the server.

The agent will read through the repo's files and respond with a proposed plan. Because Plan Mode is read-only, it cannot touch any files yet.

Why Plan Mode instead of just asking?

In default mode, the agent would immediately start editing files. Plan Mode uses a read-only subagent that can explore the codebase but has Write and Edit tools denied. This separation forces the agent to think before it acts.

The result is a structured decomposition you can review, iterate on, and approve before a single line of code changes.

Iterate on the plan and write the implementation file

The agent's first proposal might be close but imprecise. Your job is to iterate until the plan specifies three things clearly: which files each lane owns, the exact API contract, and coordination rules.

Review the agent's proposed plan. Check that it specifies:
If anything is missing or vague, ask the agent to refine. For example: "Specify the exact JSON response shape for the categories endpoint" or "Clarify which lane owns client/src/index.css."
Once the plan covers all three elements, exit Plan Mode by pressing Shift+Tab until the mode indicator returns to default (or press Shift+Tab once to cycle forward past plan back to default).
Ask the agent to write the accepted plan to implementation.md at the repo root:

Write the accepted decomposition to implementation.md at the repo root. Include: an overview, the full interface contract with JSON response shapes, Lane 1 scope and owned files, Lane 2 scope and owned files, validation commands for each lane, and coordination rules.

The agent will create implementation.md. Approve the file write when prompted.
Verify the file was created by running:

cat implementation.md

You should see the full plan with the overview, interface contract, lane scopes, and coordination rules printed in your terminal.

What should my implementation.md contain?

Your file may not be identical to someone else's since the agent writes it based on your conversation. The key elements to confirm are present:

2 lanes with non-overlapping file ownership.
An interface contract with exact endpoint paths and JSON response shapes.
Coordination rules stating neither lane modifies files owned by the other.

🙋‍♀️ Agent tried to edit files in Plan Mode?

If the agent says it cannot write files, you are still in Plan Mode. Press Shift+Tab to cycle back to default mode, then re-issue the write instruction.

Help me exit Plan Mode and write my implementation.md file.

Commit and push to GitHub

The plan document is the deliverable for this step. Committing it to your fork makes it a permanent record that a coordinator agent (or a teammate) could pick up and turn into parallel GitHub Issues.

Commit and push implementation.md by running these commands:

git add implementation.md
git commit -m "docs: add implementation plan for listings page v1"
git push

What do these commands do?

git add implementation.md stages the new file for commit.
git commit -m "..." records the change with a descriptive message. The docs: prefix follows conventional commit style for documentation changes.
git push uploads the commit to your GitHub fork.

Before you check GitHub, what do you expect to see when you open your fork's file list?

Open your fork on GitHub in your browser. Navigate to the root of the repository.
Confirm you can see implementation.md in the file list with the commit message docs: add implementation plan for listings page v1.
Click on the file and verify it contains the 2-lane decomposition, the interface contract, and coordination rules.

Don't see implementation.md on GitHub?

Make sure your git push succeeded without errors. If it asked for credentials, authenticate with GitHub and run git push again.

Check you are on the correct branch by running git branch. The active branch (marked with *) should match the default branch on your GitHub fork.

Help me push implementation.md to my GitHub fork.

You just used the full harness loop: persona loaded, guards active, Plan Mode for exploration, then a structured output the agent wrote on your behalf. That implementation.md is ready for parallel execution. In Week 2, each lane becomes its own branch and PR. For now, see if you can extend the harness further in the Secret Mission.

Looking ahead

Close the session with this, out loud: today was P1 — harness, baseline, and a plan in hand. SwapMeet doesn't stop here. Every phase after this one starts from the implementation.md (or Issue) the last phase handed off, and layers in one new concept on top of the same core cycle:

P2 (Week 2). The coordinator turns today's implementation.md into a GitHub Issue; two dev lanes poll it, build Listings Page v1, and merge.
P3–Pn (Week 3 onward). Detail pages, search, posting, an auditor lane, a public deploy — and whatever comes after the current roadmap. Each phase repeats scope → coordinate → build → review, so SwapMeet keeps growing without any session starting from zero.

The habit to leave with: a phase never ends with "it's done" — it ends with a written plan the next phase can pick up.

Secret mission

Create a /wip-pr Skill

In Week 2, each dev lane executes in its own clone. Without governance, agents might accumulate large uncommitted changes or work directly on main. Create a /wip-pr skill that enforces the branch-and-PR workflow for every lane.

Clean Up Your Resources

This project runs entirely locally and uses your existing Claude subscription. There are no ongoing cloud costs or metered charges to worry about.

Decide whether to keep your resources running, pause them to come back later, or delete them entirely.

Resources you used:

SwapMeet local clone (on your Desktop).
SwapMeet GitHub fork (on your GitHub account).
Claude Code CLI (installed via the native install script).
Personal persona and skills at ~/.claude/ (CLAUDE.md, til skill, wip-pr skill).
Running dev servers (Fastify on port 3001, Vite on port 5173).

Keep everything running

No action needed. Choose this if you plan to continue into Week 2 where you execute the dev lanes from your implementation.md plan.

Your dev servers stay running in the terminal. Press Ctrl+C when you want to stop them and restart later with npm run dev.
Your persona, skills, and guards remain loaded into every Claude Code session automatically.
Claude Code CLI stays installed and authenticated.

Pause - I'll come back to this later

Shut down running processes to free up terminal and memory. Your files and configuration stay on disk.

Switch to the terminal running the dev servers and press Ctrl+C to stop both the Fastify API and Vite client.
When you return, open a terminal in your SwapMeet folder and run npm run dev to restart.
Your persona, skills, and guards will reload automatically in any new claude session.

Delete - I don't want to use this again

Remove all project resources and start fresh. Follow each step below.

Stop the running dev servers by pressing Ctrl+C in the terminal where npm run dev is running.
Delete the SwapMeet local clone by running:

cd ~/Desktop
rm -rf swapmeet

Delete your SwapMeet GitHub fork. Open your fork on GitHub, click Settings, scroll to the Danger Zone section, then click Delete this repository. Confirm by typing the repository name and clicking Delete this repository.
Remove your personal persona and skills by running:

rm -rf ~/.claude/CLAUDE.md
rm -rf ~/.claude/skills/til
rm -rf ~/.claude/skills/wip-pr

Uninstall the Claude Code CLI binary by running:

rm -f ~/.local/bin/claude
rm -rf ~/.local/share/claude

What about the rest of ~/.claude?

The commands above remove only the persona file and skills you created in this project. If you want to remove all Claude Code settings, session history, and MCP configurations as well, run:

rm -rf ~/.claude
rm -f ~/.claude.json

Only do this if you do not use Claude Code for any other projects.

Nice Work!

You just built a full agent harness from scratch and used it to plan a real feature decomposition. Your Claude Code environment now has a persona, guards, and skills that persist across every session and every project.

Here's what you accomplished:

Configured a governed Claude Code agent with a personal ~/.claude/CLAUDE.md persona and a /til skill that load automatically into every session.
Ran the SwapMeet classifieds app with concurrent Fastify and Vite servers, then verified the agent cites its guards (log-driven validation, scope ownership, contracts before code) without prompting.
Used Plan Mode to decompose the Listings Page feature into 2 independent dev lanes with exclusive file ownership and an explicit interface contract, written to implementation.md and pushed to GitHub.
Secret Mission: Created a /wip-pr governance skill with dynamic context injection that enforces WIP PR branches and small, traceable commits for each parallel lane.

Ready to quiz yourself?