Skills / Ship on GitHub

Ship on GitHub

Get the person shipping on GitHub. Account, git on their machine, a first repo, and Pages serving a URL. Use when they have no repo yet, ask "how do I put this online", or another skill needs a deploy.

Watch the first two minutes

This is how a session goes, including the terminal part. Click through it.

Scared of the terminal?

Reasonable, and this skill is built for it. You type every command with your own hands, but never blind: each one gets a one-line explanation first, and every error gets read and fixed together instead of pasted into a panic. The skill also bans the scary stuff outright: no history rewriting, no force pushes, no committing as anyone but you. Projects that exist mostly to practice this loop:

Put a real folder under version control A repo that runs an action A real site, shipped

What you end up with

The edit-to-live loop, owned. This is the whole thing, and by the end of the session you will have run it at least three times yourself:

$ git add index.html
$ git commit -m "add opening hours to the top"  1
[main 4f2a91c] add opening hours to the top
 1 file changed, 3 insertions(+)

$ git push  2
To github.com:username/username.github.io.git
   9d1e0b2..4f2a91c  main -> main

about a minute later:  3
https://username.github.io shows the change

Questions people actually ask

Where to go from here

Loop working? Put it to work on something real:

Build a website Build a web app Deploy anywhere

Want commit practice with a payoff? Small repos that go somewhere:

Your own browser start page A one-pager behind a QR code A leaderboard for your group

Ideas to use it on

• An arcade game with your theme on it — A one-screen arcade game on a canvas: one verb (dodge, catch, shoot, jump), a threat that speeds up the longer you survive, a score, and a death.
• A janitor for your downloads folder — Your downloads folder (or camera roll export, or desktop) is a landfill you excavate by hand every few weeks.
• Family tree, rendered — Interview your parents and relatives, capture the family as a plain data file (one person per record: name, dates, parents, notes), and render it as a browsable tree.
• Ten fixes, ten commits — Clone a small template project and make ten distinct improvements to it, one commit each, using at least one branch and one merge.
• The league office for your rec league — A season platform for a rec league you play in or help run: pickup basketball, intramural volleyball, a fantasy league, a chess ladder.
• One email instead of three apps — Every morning you open the same three things: the weather, your team's score, the bus alerts, a subreddit, a webcomic.
• A newsletter platform with real subscribers — A publishing platform for a newsletter a real group already wants: your neighborhood association's monthly update, your club's weekly recap, the scout troop's announcements.
• An order desk for a real business — An order-request system for a real small business: a family bakery, a neighbor's tailoring shop, a friend's sticker shop.
• Paper to pixels — Your club or team keeps a logbook, sign-in sheet, or scorebook on paper.
• Bring a real folder under version control — Take a folder you actually maintain: school notes, game configs, art files, a half-finished project: and turn it into a repo with honest history.
• A GitHub Action that does a real job in your repo — Pick something you do by hand in one of your existing repos every time you touch it: checking that the links in the README still work, regenerating a stats table from a data file, compressing images before commit, validating that a JSON file still parses.
• A two-player versus game on one keyboard — Two friends, one keyboard: WASD versus arrow keys, first to five rounds takes the match.
• Your school's schedule as a calendar feed — Your school publishes its schedule as a PDF, a webpage, and three different emails, and you retype the parts you care about into your phone.
• A browser extension for an annoyance you can name — There is a site you use every day with one thing that drives you up the wall: autoplaying videos, a hidden per-unit price, a sidebar that eats half the screen, a timer the page does not show.
• Your own start page — The page your browser opens to, built by you for an audience of one: your links, your timetable, and a weather widget you write yourself against a free forecast API.
• Street tree survey — Every tree on your block: identified with a field guide, photographed, measured where you can, and published as a map or list backed by a data file in a public repo.
• Text adventure of your house or school — A playable text adventure set in your own house or school: real rooms, real connections between them, and the jokes only people who have been there will get.
• Volunteer hours a real org can verify — An hours platform for an organization you already volunteer with: an NHS chapter, a food bank, a library program, a religious youth group.
• A week of daily commits — A repo you commit to every day for seven consecutive days: a learning journal, practice code, or daily writing.

---
name: ship-on-github
category: web
description: Get the person shipping on GitHub. Account, git on their machine, a first repo, and Pages serving a URL. Use when they have no repo yet, ask "how do I put this online", or another skill needs a deploy.
---

# ship-on-github

Get someone onto GitHub properly: account, git that works
on their machine, a first repo, and GitHub Pages serving it at a URL.
Every other sphinxstack skill assumes this one is in place.

## Ground rules

- Their account, their name on the work. Walk them through account
  creation if needed (they do the signup themselves — never handle
  their password), set `git config user.name` / `user.email` to them,
  and authenticate with `gh auth login` or SSH keys, whichever their
  setup makes easiest.
- They run the commands. You say what to type and what it will do in
  one line; they type it. Fix errors together as they happen — error
  messages are the curriculum.
- Commit small and commit now. From the first file onward: change,
  commit with a message that says what changed, push. Make the rhythm
  automatic before it matters.
- No history rewriting, no force pushes, no committing as anyone but
  them.

## The path

1. Account exists, `git` and (ideally) `gh` installed and
   authenticated. Verify with `gh auth status` or an SSH test.
2. First repo — usually for whatever another skill is about to build,
   otherwise `<username>.github.io`. Create, clone, first commit,
   push.
3. GitHub Pages on: serve from the main branch, confirm the URL loads.
   Explain the mapping (repo → URL) in two sentences.
4. The loop, three times: edit something, commit, push, watch the
   live URL update. After the third round they own the loop.

## Done

- `git` and auth working on their machine, identity set to them
- One repo with 3+ commits in their own words
- A live GitHub Pages URL they can open on their phone
- They can say what commit, push, and deploy each mean in their own
  words

Hand back to whichever skill sent you here, or suggest build-website
/ build-web-app to put the loop to work.