Agent skill

Worktree Handoff

by hanamizuki in hanamizuki/solopreneur

Create a git worktree for a task and record handoff context into a plan file that is committed to the branch.

MITAuto-check: notesDevelopment

Install Worktree Handoff

skills CLI
$ npx skills add hanamizuki/solopreneur --skill worktree-handoff -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install hanamizuki/solopreneur worktree-handoff --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/hanamizuki/solopreneur.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/solopreneur/worktree-handoff .claude/skills/worktree-handoff && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
worktree-handoff
GitHub stars
152
Token cost
~3.2k tokens
SKILL.md length
832 words
Files
1
Skills in repo
31
Repo updated
First seen
Licence
MIT

At a glance

Create a git worktree for a task and record handoff context into a plan file that is committed to the branch.

  • Works in 8 steps: Resolve Mode and Paths → Decide Worktree Name and Branch → Create Worktree → …
  • The user says open worktree
  • SKILL.md covers Codex host guard, Flow and Example
  • Calls git, jq and python3

What it does

Worktree Handoff is an agent skill from hanamizuki/solopreneur. Create a git worktree for a task and record handoff context into a plan file that is committed to the branch. Discovers existing plan files in the user's configured todos or plans directory, appends a dated Handoff Context section, and commits everything before printing the next-session pickup message. Use when the user says "open worktree", "worktree handoff", "create a worktree", "start a new branch for this", or wants to hand off a task to a fresh session with full context preserved.

Its SKILL.md is about 3.2k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Development, covering Git worktrees. It works with Git. The repository describes itself as: Skills and agents for solopreneurs — ship, review, debug, and think through problems with AI. The licence is MIT.

When your agent uses it

  • The user says open worktree
  • Worktree handoff
  • Create a worktree
  • Start a new branch for this

Example prompts

  • “open worktree”
  • “worktree handoff”
  • “create a worktree”
  • “/worktree-handoff”

Requirements

  • Python 3

Workflow steps

8 steps, taken from the step headings in SKILL.md.

  1. Resolve Mode and Paths
  2. Decide Worktree Name and Branch
  3. Create Worktree
  4. Copy Environment Config Files (gitignored secrets/config)
  5. Discover Candidate Plan Files + Context-Aware Picker
  6. Prepare the Plan File
  7. Commit and Push
  8. Output the Next-Session Pickup Message

What it can do on your machine

Read from SKILL.md and the folder at commit f43f001. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • git
    • jq
    • python3

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md. Its commands use git, which can reach the network depending on how they are called.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Worktree Handoff loads about 3.2k tokens when it runs. Until then it costs about 127 tokens; SKILL.md has 832 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~127
When it runs · the whole SKILL.md, loaded when a task matches
~3.2k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check: notes

The automated check noted patterns worth knowing about, such as sudo or a known installer.

  • NoteMentions a .env fileSKILL.md:112
    # Common patterns: .env, *.xcconfig, local.properties, secrets.json

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from hanamizuki/solopreneur at commit f43f001, republished under its MIT licence (© hanamizuki). 832 words, ~3,215 tokens.

Download SKILL.mdSave it as .claude/skills/worktree-handoff/SKILL.md (or your agent's skills folder).
name
worktree-handoff
description
Create a git worktree for a task and record handoff context into a plan file that is committed to the branch. Discovers existing plan files in the user's configured todos or plans directory, appends a dated Handoff Context section, and commits everything before printing the next-session pickup message. Use when the user says "open worktree", "worktree handoff", "create a worktree", "start a new branch for this", or wants to hand off a task to a fresh session with full context preserved.

Worktree Handoff

Codex host guard

Before any other action, check whether CODEX_THREAD_ID is set. If it is, stop before creating a worktree or branch, copying configuration, changing a plan, or committing. This release supports Worktree Handoff only on Claude Code; tell the user the Codex worktree seam is not shipped yet and to run the workflow there instead.

Create an isolated workspace for a new or in-progress task, and record the complete task context into a plan file that gets committed to the branch. The next session reads the plan file to pick up without re-explanation.

Flow

Step 1: Resolve Mode and Paths

Source the cascade config helpers, then determine the operating mode:

bash
# --- solopreneur config helpers (sourced from shared/config.sh) ---
# One real shell file, so no harness rewrites the helpers on the way to the
# shell. Claude Code replaces the ${CLAUDE_SKILL_DIR} token below when it loads
# this body; Codex does not. It is SINGLE-quoted on purpose — it is a load-time
# token, not an environment variable, and letting the shell expand the name
# would source whatever an inherited value happened to point at. Unreplaced, it
# is not a directory, so substitute the absolute path of the directory holding
# THIS SKILL.md — every harness states that path to the model.
SOLO_SKILL_DIR='${CLAUDE_SKILL_DIR}'
[ -d "$SOLO_SKILL_DIR" ] || SOLO_SKILL_DIR="<absolute path of the directory holding this SKILL.md>"
SOLO_CONFIG_SH="$SOLO_SKILL_DIR/../../shared/config.sh"
# Three candidates, one contract. Inside the plugin the helpers sit at ../../shared/;
# authoring against this repo reaches them under src/solopreneur/shared/; and a
# skill republished on its own — any flattened skills directory — carries them
# at scripts/config.sh instead, because shared/ is a sibling of skills/ and does
# not travel with a per-skill copy. Try each in order, then STOP. Sourcing a
# file that is not there does not halt the shell: every helper stays undefined,
# every config read returns empty, and the 2026-08-11 A2 run showed where that
# leads — the model "rescued" it with a repo-relative path, which resolves only
# when the repo under review happens to be this plugin's own source repo.
# Canonical authoring keeps non-skill source under src/.
[ -f "$SOLO_CONFIG_SH" ] || SOLO_CONFIG_SH="$SOLO_SKILL_DIR/../../../src/solopreneur/shared/config.sh"
[ -f "$SOLO_CONFIG_SH" ] || SOLO_CONFIG_SH="$SOLO_SKILL_DIR/scripts/config.sh"
[ -f "$SOLO_CONFIG_SH" ] || { echo "HALT: solopreneur config helpers not found under $SOLO_SKILL_DIR — stop here, do not improvise a path"; exit 1; }
source "$SOLO_CONFIG_SH"
# --- end solopreneur config helpers ---

TODOS_CONFIG=$(read_solopreneur_config todos)
PLANS_CONFIG=$(read_solopreneur_config plans)

BACKLOG=$(echo "${TODOS_CONFIG:-{}}" | jq -r '.backlog // empty')
DOING=$(echo "${TODOS_CONFIG:-{}}" | jq -r '.doing  // empty')
PLANS_DIR=$(echo "${PLANS_CONFIG:-{}}" | jq -r '.dir // empty')
PLANS_DIR="${PLANS_DIR:-docs/solopreneur/plans}"  # default
MODE=$([ -n "$BACKLOG" ] && [ -n "$DOING" ] && echo "state-machine" || echo "flat")

Mode decision:

  • State-machine mode: $BACKLOG and $DOING are both non-empty
  • Flat mode: otherwise — uses $PLANS_DIR
Step 2: Decide Worktree Name and Branch

Name based on task type and description:

Task TypeBranch PrefixExample
Bug fixfix/fix/sleep-calculation
New featurefeature/feature/health-connect-edit
Refactorrefactor/refactor/sleep-sessionizer
Researchresearch/research/healthkit-sources

Worktree directory name = branch name slug (strip prefix, use - separators).

Step 3: Create Worktree

Always place worktrees under .worktrees/:

bash
git worktree add .worktrees/<slug> -b <branch-name>

Prohibited: operating on main, placing worktrees outside .worktrees/.

Step 4: Copy Environment Config Files (gitignored secrets/config)

Worktrees are separate directories — gitignored files don't carry over automatically. Check .gitignore for config/secret patterns, find matching files in the main repo, copy them to the same relative paths in the worktree. Never copy build artifacts.

bash
# The main repo is the first worktree. `--porcelain` puts the path on its own
# `worktree <path>` line, so a path containing spaces survives — and no `$N`
# lands in a skill body (see ../../shared/config.sh for why that matters).
MAIN_REPO="$(git worktree list --porcelain | sed -n 's/^worktree //p' | head -1)"
WORKTREE=".worktrees/<slug>"

# Find gitignored config files that exist in the main repo
# Common patterns: .env, *.xcconfig, local.properties, secrets.json
# Copy any that are relevant to this project to the worktree's corresponding paths
Step 5: Discover Candidate Plan Files + Context-Aware Picker

Collect all plan files:

bash
# State-machine mode: collect from backlog + doing
if [ "$MODE" = "state-machine" ]; then
  ALL_FILES=$(find "$BACKLOG" "$DOING" -maxdepth 1 -name "*.md" 2>/dev/null)
else
  mkdir -p "$PLANS_DIR"
  ALL_FILES=$(find "$PLANS_DIR" -maxdepth 1 -name "*.md" 2>/dev/null)
fi

Context matching — before prompting the user:

Extract 3–5 key terms from the current conversation (task name, feature area, keywords from the user's description). Then score each plan file:

  1. Search file names (basename) for the key terms
  2. Search file content (title headings, Plan-Branch: lines, first 20 lines) for the key terms
bash
# ILLUSTRATIVE ONLY — substitute actual key terms extracted from the current
# conversation before running. Do NOT execute this block with these hardcoded terms.
TERMS="<term1>\|<term2>\|<term3>"  # replace with actual key terms
CANDIDATES=""
while IFS= read -r f; do
  [ -z "$f" ] && continue
  score=$(head -20 "$f" | grep -i -c "$TERMS" 2>/dev/null); score=${score:-0}
  name_score=$(basename "$f" | grep -i -c "$TERMS" 2>/dev/null); name_score=${name_score:-0}
  total=$((score + name_score * 2))
  [ "$total" -gt 0 ] && CANDIDATES="$CANDIDATES\n$total $f"
done <<< "$ALL_FILES"
CANDIDATES=$(printf '%b' "$CANDIDATES" | sort -rn)
MATCH_COUNT=$([ -n "$CANDIDATES" ] && printf '%b' "$CANDIDATES" | grep -c . || echo 0)

Match count = number of files with a score greater than zero (i.e., at least one key term found in the filename or first 20 lines of content).

Decision based on match count:

  • 0 matches — if $ALL_FILES is non-empty, briefly tell the user: "No matching plans found for this task — creating a new plan file. (Reply with a filename to use an existing plan instead.)" Then proceed to Step 6 to create a new file.

  • 1 match — use it automatically, no prompt. Print: → Matched plan: <filename> so the user knows what was selected.

  • 2+ matches — show only the matching candidates (not all files) with index numbers, then ask:

    "Found N matching plans. Which one does this worktree belong to? Enter a number to reuse it, or 'new' to create a fresh plan file."

    In state-machine mode, note the source directory in parentheses (Backlog / Doing) next to each filename.

If no plan files exist at all, skip all of the above and proceed directly to creating a new file.

Recording the source: When a file is selected, set PLAN_SOURCE=backlog or PLAN_SOURCE=doing based on which directory it came from. Step 6 checks $PLAN_SOURCE to decide whether to run git mv (only when PLAN_SOURCE=backlog).

Step 6: Prepare the Plan File
If user picked 'new' (or no plans exist)

Create a new file:

  • State-machine mode: <doing>/<YYYY-MM-DD>-<branch-slug>.md
  • Flat mode: <plans-dir>/<YYYY-MM-DD>-<branch-slug>.md

Where <branch-slug> = branch name with / replaced by - (e.g., fix/sleep-calculation → fix-sleep-calculation). Date from $(date +%Y-%m-%d).

New file content:

markdown
<!--
Plan-Branch: <branch-name>
-->

## Handoff Context (<YYYY-MM-DD>, branch: <branch-name>)

### Problem Background
<why is this being done — user reports, screenshots, logs>

### Root Cause
<known technical issues, with file paths + line numbers>

### Items to Fix / Implement
- [ ] <item with expected approach>

### Key Files
| path | description |
|------|-------------|

### Current Progress
Not started.

Fill in the five sections based on context from the current conversation.

Show full SKILL.md (373 more words)Show less
If user picked an existing file
  1. Move from backlog to doing (state-machine mode only): If the selected file is in $BACKLOG, move it:

    bash
    git mv "$BACKLOG/<filename>" "$DOING/<filename>"
    PLAN_FILE="$DOING/<filename>"

    In flat mode, skip this step — the file stays in place.

  2. Ensure the Plan-Branch: marker block exists at the top of the file. If the file already starts with an HTML comment block containing at least one Plan-Branch: line, check whether Plan-Branch: <branch-name> is already present. If it is absent, append the line inside the existing comment block:

    bash
    python3 -c "
    import sys
    branch, path = sys.argv[1], sys.argv[2]
    with open(path) as f: content = f.read()
    idx = content.find('\n-->')
    if idx != -1:
     content = content[:idx+1] + 'Plan-Branch: ' + branch + '\n' + content[idx+1:]
    with open(path, 'w') as f: f.write(content)
    " "<branch-name>" "$PLAN_FILE"

    If no comment block exists at the top (legacy file), prepend one:

    markdown
    <!--
    Plan-Branch: <branch-name>
    -->
  3. Append the handoff section at the end of the file:

    markdown
    
    ## Handoff Context (<YYYY-MM-DD>, branch: <branch-name>)
    
    ### Problem Background
    <why is this being done — user reports, screenshots, logs>
    
    ### Root Cause
    <known technical issues, with file paths + line numbers>
    
    ### Items to Fix / Implement
    - [ ] <item with expected approach>
    
    ### Key Files
    | path | description |
    |------|-------------|
    
    ### Current Progress
    <not started / steps done so far>

    Fill in the five sections based on context from the current conversation. Be specific: include file names, line numbers, error messages, actual numbers. Include root cause analysis already done so the next session doesn't debug from scratch. If the conversation had screenshots or user-reported bug details, include everything.

Step 7: Commit and Push
bash
git add <plan-file-path>
# Also stage the git mv result if the file moved from backlog to doing
git commit -m "docs(handoff): context for <branch-name>"
git push -u origin <branch-name>

Single commit. Push immediately so the doc is visible to the next session and to PR reviewers.

Step 8: Output the Next-Session Pickup Message

Print this so the user can paste it into a new session:

text
cd /absolute/path/to/repo/.worktrees/<slug>

Plan file: <relative/path/to/plan.md>
Read the plan file for the full context — branch <branch-name> is tracked under
the `Plan-Branch:` marker, and the latest `## Handoff Context` section captures
the current state.
Branch: <branch-name>, <one-line task description>.

Use an absolute path in the cd command (from git worktree list). The plan file path should be relative to the repo root.

Example

User says: "Open a worktree to fix the sleep calculation — the issue is duplicate sources from HealthKit"

bash
git worktree add .worktrees/fix-sleep-calculation -b fix/sleep-calculation

Plan file discovery: user picks existing 2026-04-10-sleep-tracking.md from backlog (state-machine mode). File is git mv'd to doing, Plan-Branch: fix/sleep-calculation is added to the marker block, and the Handoff Context section is appended with the HealthKit duplicate-source root cause detail.

Commit: docs(handoff): context for fix/sleep-calculation

Output for user:

text
cd /path/to/project/.worktrees/fix-sleep-calculation

Plan file: docs/solopreneur/plans/doing/2026-04-10-sleep-tracking.md
Read the plan file for the full context — branch fix/sleep-calculation is tracked
under the `Plan-Branch:` marker, and the latest `## Handoff Context` section
captures the current state.
Branch: fix/sleep-calculation, deduplicate HealthKit multi-source sleep samples
so displayed sleep time matches Apple Health's value.

© hanamizuki, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in skills/solopreneur/worktree-handoff of hanamizuki/solopreneur.

Open the folder on GitHubat commit f43f001

Compare with similar skills

Worktree Handoff next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Worktree Handoff compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Worktree Handoff this skillhanamizuki/solopreneur152—~3.2kAutomated safety check: NotesMIT
Finishing a Development Branchobra/superpowers297k5 repos~1.9kAutomated safety check: PassMIT
Finishing A Development Branchfarm-fe/farm5.6k34 repos~1.8kAutomated safety check: PassMIT
Git Worktree Cleanuplobehub/lobehub83k—~2.8kAutomated safety check: PassCustom licence
Pre-Release PR Triagejamiepine/voicebox57k—~3.1kAutomated safety check: PassMIT
Ccmanager Configkbwo/ccmanager1.3k—~1.5kAutomated safety check: PassMIT

Similar skills

  • Walks the last step of a branch: confirm tests pass, detect the git environment, ask how to integrate, carry out your choice and clean up the worktree.

    297k GitHub starsUsed in 5 repos~1.9k tokens
    DevelopmentAuto-check passed
  • A skill your agent uses when implementation is complete, all tests pass, and you need to decide how to integrate the work - guides completion of development work by presenting structured options for…

    5.6k GitHub starsUsed in 34 repos~1.8k tokens
    DevelopmentAuto-check passed
  • Git Worktree Cleanup

    lobehub/lobehub

    Audits stale Git worktrees and branches with a bundled script, classifies each one, and deletes only after you approve the exact candidates.

    83k GitHub stars~2.8k tokensUpdated today
    DevelopmentAuto-check passed
  • Pre-Release PR Triage

    jamiepine/voicebox

    Sorts a backlog of open pull requests into must-merge, candidate, superseded and deferred, writes a triage doc and works the merge loop before a release.

    57k GitHub stars~3.1k tokensUpdated 3 days ago
    DevelopmentAuto-check passed
  • Ccmanager Config

    kbwo/ccmanager

    Set up, review, or repair a CCManager config — .ccmanager.json at a git repository root, or the global ~/.config/ccmanager/config.json.

    1.3k GitHub stars~1.5k tokensUpdated yesterday
    DevelopmentAuto-check passed
  • Builds a Cap feature in an isolated Git worktree with disposable dev resources, verification, a recorded demo and a neutral pull request, started with /building.

    23k GitHub stars~2.5k tokensUpdated today
    DevelopmentAuto-check: warnings

More from hanamizuki/solopreneur

All 31 skills in this repo
  • Preview

    hanamizuki/solopreneur

    Create an interactive HTML preview of any proposal, plan, idea, doc, brief, or spec and land it in the browsable local Preview Library by default (opens under file:// with a catalog sidebar and…

    152 GitHub stars~5.2k tokensUpdated 13 days ago
    Auto-check passed
  • iOS Patterns

    hanamizuki/solopreneur

    A skill your agent uses when building iOS/macOS apps with SwiftUI — covers localization (String Catalogs), date/time formatting, JSON date decoding, Previews, state management, sheet/navigation…

    152 GitHub stars~2.3k tokensUpdated 13 days ago
    Auto-check: notes
  • Linkedin Growth

    hanamizuki/solopreneur

    LinkedIn organic growth consultant — diagnoses profiles, discusses goals, and co-creates a personalized 90-day growth plan.

    152 GitHub stars~3.7k tokensUpdated 13 days ago
    Auto-check passed
  • Perspective

    hanamizuki/solopreneur

    Switch perspectives to think through problems using the mental models of ten iconic thinkers: Elon Musk, Richard Feynman, Charlie Munger, Naval Ravikant, Steve Jobs, Nassim Taleb, Ilya Sutskever…

    152 GitHub stars~971 tokensUpdated 13 days ago
    Auto-check passed
  • Slide Design

    hanamizuki/solopreneur

    Create brand-aware presentations using frontend-slides or reveal.js.

    152 GitHub stars~3.9k tokensUpdated 13 days ago
    Auto-check passed
  • X Growth

    hanamizuki/solopreneur

    X/Twitter growth consultant — diagnoses profiles, discusses goals, and co-creates a personalized growth plan.

    152 GitHub stars~3.8k tokensUpdated 13 days ago
    Auto-check passed

Works with

Categories

Questions about Worktree Handoff

What does Worktree Handoff do?

Create a git worktree for a task and record handoff context into a plan file that is committed to the branch. Worktree Handoff is an agent skill from hanamizuki/solopreneur. Create a git worktree for a task and record handoff context into a plan file that is committed to the branch.

When should I use Worktree Handoff?

Worktree Handoff fits situations like: the user says open worktree; worktree handoff; create a worktree; start a new branch for this.

How do I install Worktree Handoff in Claude Code?

Run `npx skills add hanamizuki/solopreneur --skill worktree-handoff -a claude-code`. Or copy the skill folder (skills/solopreneur/worktree-handoff in hanamizuki/solopreneur) into .claude/skills/worktree-handoff in your project. Claude Code loads it when a task matches its description.

How do I install Worktree Handoff in Codex?

Run `npx skills add hanamizuki/solopreneur --skill worktree-handoff -a codex`. Or copy the skill folder (skills/solopreneur/worktree-handoff in hanamizuki/solopreneur) into .agents/skills/worktree-handoff in your project. Codex loads it when a task matches its description.

Can I use Worktree Handoff in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add hanamizuki/solopreneur --skill worktree-handoff -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/worktree-handoff, .gemini/skills/worktree-handoff, .github/skills/worktree-handoff and .opencode/skills/worktree-handoff in your project.

What does Worktree Handoff need to run?

Going by SKILL.md and its folder, Worktree Handoff needs the command-line tools its instructions call (git, jq and python3). Our summary lists: Python 3.

Does Worktree Handoff access the network?

SKILL.md contains no URLs. Its commands use git, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Worktree Handoff safe to install?

Our automated static check of SKILL.md found notes only (mentions a .env file), nothing it rates as a warning. It is not a guarantee. Review the folder before installing.

What licence does Worktree Handoff use?

Worktree Handoff is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Worktree Handoff use?

About 3.2k tokens (SKILL.md is roughly 13k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Worktree Handoff?

Skills that share tags, products or a category with Worktree Handoff: Finishing a Development Branch (obra/superpowers, 297k stars), Finishing A Development Branch (farm-fe/farm, 5.6k stars), Git Worktree Cleanup (lobehub/lobehub, 83k stars) and Pre-Release PR Triage (jamiepine/voicebox, 57k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Worktree Handoff?

hanamizuki (a GitHub user) maintains it in hanamizuki/solopreneur, which has 152 GitHub stars. The repository holds 31 skills in this directory. The repository was last updated on September 26, 2026.

Source: hanamizuki/solopreneur on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.