Getting Started Home
●  Tutorial

Getting Started with Slop

From install to your first autonomous PR in 15 minutes. Follow these steps and you will have an AI agent implementing and merging real GitHub issues - entirely on your laptop, no cloud deploy required.

Step-by-step First-run tutorial 15 min macOS / Linux / WSL
Before you begin
Prerequisites
Make sure you have everything below before starting. Each item takes only a moment to check.
Node.js 25+
Run node -v to verify. Use nvm or fnm to install if needed.
pnpm 11.3.0+
npm install -g pnpm then pnpm -v to verify.
Git
Any recent version. Run git --version to confirm.
GitHub PAT
Personal Access Token with repo + workflow scopes. Create at github.com/settings/tokens.
A target GitHub repo
A repo you want Slop to work on. Must have CI (GitHub Actions) configured and branch protection on main.
macOS or Linux
Windows users: run everything inside WSL 2. Native Windows is not supported.
Branch protection required. Your target repo's base branch must have at least one required CI status check enabled (GitHub repo Settings > Branches). Without it, Slop's guard check will prevent merges. Set this up now before you get to Step 7.
1
Step 1
Clone and Install

Clone the Slop repository to your machine, then install all dependencies.

Terminal
git clone https://github.com/your-org/slop
cd slop
make install

make install runs pnpm install and generates the Prisma client from the database schema. It should complete in about 60 seconds on a warm npm cache.

When it finishes without errors, you are ready for the next step. If you see Prisma errors about missing environment variables, that is expected - you will add them in Step 2.

Heads up: The Slop source repo and your watched repo are two separate things. Slop itself is the tool you just cloned. Your watched repo is the project you want Slop to implement issues for. You will point Slop at the watched repo in Step 4.
2
Step 2
Configure Environment

Create a .env.local file in the root of the Slop directory. This file holds your secrets and local paths - it is never committed to git.

.env.local
GITHUB_TOKEN=ghp_xxxxxxxxxxxxxxxxxxxx
WORKTREES_ROOT=/Users/you/.slop/worktrees
PORT=3100
SLOP_URL=http://localhost:3100
GITHUB_TOKEN
Your GitHub Personal Access Token. Needs repo and workflow scopes. One token covers all watched repos.
WORKTREES_ROOT
Directory where the agent's git worktrees will be created. The directory will be auto-created. Use a fast local disk - not a network drive or cloud-synced folder. Worktrees do heavy disk I/O.
PORT
Port for the Next.js server. Defaults to 3000. Convention is 3100 for dev to avoid conflicts with other local services.
SLOP_URL
The full URL Slop is accessible at. Required if you use a non-default port. The daemon uses this to construct callback URLs.
Agent tokens: If you want to use the Claude harness (default), you also need ANTHROPIC_API_KEY set here. For Codex, add OPENAI_API_KEY. You can add these now or later from the Config page. See the Configuration reference for the full list.
3
Step 3
Start the Server

Run the development server. This starts both the Next.js UI and the background worker daemon together.

Terminal
make dev

You should see output from both Next.js (port 3100) and the daemon startup sequence. Wait until you see something like ready - started server on 0.0.0.0:3100.

Open http://localhost:3100 in your browser. You will see the Slop board. The board will be empty because you have not added a watched repo yet.

Quick check: Open http://localhost:3100/api/health. You should get a JSON response with "ok": true and daemon status. If you see an error, check your .env.local file and restart make dev.
4
Step 4
Add a Watched Repo

Slop needs to know which GitHub repository to work on. You configure this as a "watched repo" on the Config page. You need both a GitHub remote and a local checkout.

Make sure your target repo is already cloned locally before this step:

Terminal - in a separate directory
# If you haven't already cloned your target repo:
git clone https://github.com/myorg/myrepo /Users/you/code/myrepo

Then in the Slop UI:

  1. Click Config in the sidebar
  2. Under "Repositories", click Add Repository
  3. Fill in the form:
    • Owner/Name: e.g. myorg/myrepo
    • Local Path: absolute path to your local checkout, e.g. /Users/you/code/myrepo
    • Base Branch: usually main or master
  4. Click Save
Harness bootstrap: After saving, Slop automatically runs harness/bootstrap.sh inside your local checkout. This installs the agent skills the AI needs to operate in that repo. You do not need to run it manually.
This Slop repo is not a watched repo by default. The repo you just cloned is the tool. Your watched repo is the separate project you want issues implemented in. You can add the Slop repo itself as a watched repo later if you want to dogfood it.
5
Step 5
Enable Auto Mode

By default, Slop sits idle and waits for you to manually trigger work. Enabling Auto Mode lets the daemon claim and implement issues automatically as they enter the Ready queue.

On the Config page, toggle these settings:

Auto Mode
Turn on. The daemon will automatically claim issues from the Ready queue and begin implementing them. Without this, issues sit in Ready until you manually trigger a worker run.
Auto Merge
Turn on if you want fully autonomous operation. After CI passes, Slop merges the PR and closes the issue. Turn it off if you prefer to review PRs before merging.
Auto Review
Optional. Runs an AI review pass on the PR before merging. Adds a comment with findings. Good for catching obvious problems, but not a substitute for human review on critical changes.
Agent Model
Choose the default AI model for new workers. claude-opus-4 is best for complex, multi-file changes. claude-sonnet-4 is faster and cheaper, good for most tasks. You can override per-issue.
For your first run: Enable Auto Mode and Auto Merge. This gives you the full autonomous experience. You can always turn off Auto Merge later once you're comfortable with what the agent produces.
6
Step 6
Queue Your First Issue

Go back to the Board (the main page). You should now see issues from your watched repo loaded in the Backlog column. If it's empty, wait about 30 seconds and refresh - the first snapshot takes one poll cycle to populate.

Pick a small, well-defined issue for your first run. Good candidates:

  • A clear bug fix with a specific reproduction step
  • A simple UI change with explicit requirements
  • Adding a unit test for an existing function
  • A documentation update

Avoid large or ambiguous issues for your first run. The agent works best when the task is scoped.

Once you've picked an issue:

  1. Click the issue card to open the detail view
  2. Click Set Ready to move it to the Ready queue
  3. (Optional) Set Story Points to estimate complexity: 1-3 for small, 5-8 for medium, 13+ for large. This affects token budgets.
  4. (Optional) Override the agent model for this specific issue if it differs from your default
No labels required. Slop does not watch for GitHub labels. An issue enters the Ready queue only when you click Set Ready in the board UI (GitHub issues) or mark it ready in the internal issue tracker. This keeps you in full control of what gets picked up.
7
Step 7
Watch It Work

With Auto Mode on, the daemon claims your issue within about 30 seconds on the next poll cycle. The issue card moves from Ready to In Progress.

Click the card to open the live worker view. You will see real-time output streaming from the agent - what it's reading, what changes it's making, and which tools it's calling. Token usage and cost accumulate in the panel as the agent works.

Typical flow
1
Daemon claims the issue
The poll loop picks up your ReadyIssue row and creates an isolated git worktree at WORKTREES_ROOT/<repoId>/<issueNumber>.
2
Agent reads and implements
The AI agent reads the issue body, explores your codebase, and implements the change. It uses the skills installed during bootstrap to run tests and lint.
3
Agent commits and opens a PR
Once satisfied, the agent commits the changes, pushes the branch (slop/issue-N), and opens a pull request. The PR appears on your watched repo immediately.
4
Slop waits for CI
The daemon polls CI status on the PR. If CI fails, the agent retries up to 5 times, reading the failure output and patching the code. This is fully automatic.
5
PR merges, issue closes
With Auto Merge on: after CI passes and guard checks clear, Slop merges the PR. The worktree is cleaned up. The issue is closed. The card moves to Done.
8
Step 8
Your First PR

Go to your watched repo on GitHub. You will see a new pull request opened by the agent on a branch named slop/issue-<N>.

The PR contains:

  • The implementation commit(s) with a descriptive message
  • A PR body summarizing the approach the agent took
  • No "Closes #N" line - Slop closes the issue directly after the merge, not via the PR body

If Auto Merge is on and CI passes, you should see the PR merge itself within a few minutes of CI completion. Check the Board - the card will be in the Done column.

Congratulations. You just had an AI agent autonomously implement, test, and merge a GitHub issue on your behalf. That's the full Slop loop. From here, you can queue more issues, tune the model, add more watched repos, or explore the configuration options below.
Help
Common First-Run Problems
If something doesn't go as expected, check these common issues before digging further.
"No issues showing on board"
The GitHub snapshot is populated on the daemon's poll cycle, which runs approximately every 30 seconds. After adding your watched repo, wait 30-60 seconds and refresh the page. If issues still don't appear, check that your GITHUB_TOKEN has repo scope and that the owner/name slug matches exactly (case-sensitive).
"Worker stuck in claimed"
The worker started but cannot proceed. Two most common causes: (1) WORKTREES_ROOT is not writable - check permissions and that the path exists. (2) GITHUB_TOKEN is missing the workflow scope, which is required to push to protected branches. Check the worker log (click the card in the board) for the exact error.
"CI failing repeatedly"
The agent retries CI failures automatically up to 5 times, reading the error output each time. If it keeps failing after 5 attempts, the issue is likely too complex or the repo has a test environment the agent can't reproduce. Click the worker card and review the full log to see what the agent tried. You may need to clarify the issue description or break it into smaller tasks.
"Guards failed - cannot merge"
Slop's guard check requires at least one required CI status check on your base branch. Go to your watched repo on GitHub: Settings > Branches > Branch protection rules > select your base branch > enable "Require status checks to pass" and add at least one CI context. Save the rule, then retry the worker from the board.
"Server won't start / Prisma error"
Run make install again to re-generate the Prisma client. If you recently updated the schema, run pnpm exec prisma db push --accept-data-loss to sync the database. For a completely fresh start, delete slop.db and restart make dev.
Continue learning
What's Next
You've got the basics down. Here's where to go depending on what you want to do next.