Agent Skills: Navigating GitHub

Navigating GitHub

First-time GitHub setup and interactive git learning. Get set up, then learn by doing.

Table of Contents

1. Overview — 2. Prerequisites — 3. Instructions — 4. Modes — 5. Examples — 6. Output — 7. Resources

Overview

Problem: Getting started with GitHub is the #1 barrier for people building with AI. Beginners stall at setup, don't understand commits vs pushes vs PRs, and have nobody to walk them through it hands-on. AI coding tools can run git commands, but they don't teach you what those commands mean or guide you through setup from scratch.

Solution: Walk users through GitHub setup step by step, then teach git and GitHub through 9 progressive hands-on lessons on their actual project. Every lesson uses do-then-explain: run the command, see the result, then understand why. Adapts language and depth to skill level automatically.

Prerequisites

• Terminal access with git installed
• gh CLI installed (Setup handles installation if missing)
• GitHub account (Setup handles creation if missing)

Instructions

Step 1 — Route

Determine mode from the user's request. Act immediately — no preamble.

1. No .git/ directory OR gh auth status fails → Setup (check with test -d .git and gh auth status)
2. Keywords "teach", "learn", "what are", "how do", "explain", "lesson" → Learn
3. Keywords "set up", "new repo", "init", "get started" → Setup
4. Generic ("help me with github") → check environment, route to Setup if no repo, otherwise offer lesson menu

Step 2 — Infer Skill Level

Each mode runs git status as part of its normal operation. Infer level from those signals — no extra commands:

• Only main branch + short/vague commit messages → Beginner
• A few branches + descriptive commits → Intermediate
• Branch naming conventions + conventional commits → Advanced
• Complex history, multiple remotes, CI configured → Expert

Only ask via AskUserQuestion when signals are genuinely ambiguous. Read ${CLAUDE_SKILL_DIR}/references/skill-assessment-guide.md for the full adaptive behavior matrix. Apply:

| Level | Language | Depth | Autonomy | |-------|----------|-------|----------| | Beginner | Analogies, zero jargon | Explain everything | Execute and teach along the way | | Intermediate | Light jargon, define terms | Explain the why | Execute, ask to confirm | | Advanced | Standard vocabulary | Brief rationale only | Suggest, let user decide | | Expert | Terse, technical | None unless asked | Assist only |

Modes

Setup — Guided Onboarding

The core experience for first-time users. Walk through each step interactively, skipping anything already done. Run each check, explain what it means, fix what's missing.

Sequence: Check gh auth status → install gh if missing (detect OS, give command) → run gh auth login (walk through browser OAuth) → check git config user.name and user.email (set if missing) → check for .git/ (run git init if missing) → generate .gitignore by detected project type → create first commit → run gh repo create (let user choose public/private) → push → show the repo URL.

Skip completed steps. Explain each step at the inferred level. After completion, offer the lesson menu: "Repo is set up. Say 'teach me github' or run /github-learn to start learning."

Learn — Interactive Curriculum

Hands-on lessons using real commands on the user's actual project. Every lesson follows do-then-explain: run a real command, observe the result, THEN explain what happened. Verify understanding after each step before proceeding.

Read ${CLAUDE_SKILL_DIR}/references/learning-curriculum.md for the full curriculum. Route by trigger:

Beginner track:

• "teach me github" / "learn github" → GitHub 101 — commits, push, the basics
• "what are branches" / "teach me branches" → Branching Basics — create, switch, see the difference
• "teach me PRs" → Your First PR — branch, push, create PR, merge

Intermediate track:

• "teach me branching strategies" → Branch Workflows — naming, feature branches, staying current
• "teach me code review" → PR Review Flow — review, comment, approve
• "how do I collaborate" → Team Git — forks, upstream sync, co-authoring

Advanced track:

• "teach me rebase" → Rebase vs Merge — interactive rebase, squash, clean history
• "teach me CI/CD" / "github actions" → GitHub Actions — write a workflow, watch it run
• "how do code review apps work" → Review Ecosystem — CodeRabbit, Copilot Review, and the ecosystem (read ${CLAUDE_SKILL_DIR}/references/github-review-apps.md)

After each lesson: summarize what was learned (2-3 bullets), give a small challenge to try solo, suggest the next lesson.

Teaching rules:

• Run commands one at a time, explain after each result
• If the user makes a mistake, fix it together — mistakes are learning moments
• If the user already knows something, skip ahead
• If the user seems confused, slow down and simplify
• Create a safe practice branch before exercises that modify the repo
• Never push to main/master during lessons — always branch first
• Never commit secrets — check for .env, API keys before staging

Examples

Setup (no .git, no auth):

User: "help me with github"
Agent: [checks — no .git, gh not authenticated]
Agent: "Starting from scratch. First, connect to GitHub..."
Agent: [walks through gh auth login, git config, git init, gh repo create]
Agent: "Repo is live at github.com/user/project. Run /github-learn to
       start learning commits and branches."

Learn (beginner, GitHub 101):

User: "teach me github"
Agent: "Make a small change to any file — add a comment, fix a typo."
User: [edits a file]
Agent: "Now save that change: git add README.md"
Agent: "That moved the change to the staging area — like putting a letter
       in an envelope. Now seal it: git commit -m 'Update README'"
Agent: [verifies understanding before moving to next step]

Learn (advanced, rebase):

User: "/github-learn rebase"
Agent: "Create a branch with 3 small commits, then we'll squash them."
Agent: [guides through git rebase -i, explains pick/squash/fixup]

Output

Calibrate all output to the inferred skill level. Beginner: plain English with analogies, explain every command. Intermediate: concise summaries, explain rationale. Advanced: minimal commentary. Expert: raw output only. Read ${CLAUDE_SKILL_DIR}/references/git-concepts-glossary.md when a term definition is needed.

Error Handling

• gh not installed: Detect missing CLI, provide platform-specific install instructions (brew install gh, apt install gh, winget install GitHub.cli), then resume setup.
• Authentication failure: If gh auth status fails, walk through gh auth login with browser OAuth flow. If token is expired, run gh auth refresh.
• No git remote: If git remote -v returns empty, guide through gh repo create or git remote add origin <url>.
• Merge conflict during lesson: Explain what a conflict is at the user's level, show the conflict markers, and walk through resolution step by step.
• Detached HEAD: Detect with git status, explain in plain language, and recover with git checkout <branch>.

Resources

• ${CLAUDE_SKILL_DIR}/references/learning-curriculum.md — 9 progressive lesson plans from beginner through advanced
• ${CLAUDE_SKILL_DIR}/references/git-concepts-glossary.md — term definitions at beginner and technical levels
• ${CLAUDE_SKILL_DIR}/references/skill-assessment-guide.md — adaptive behavior matrix with level-up and level-down signals
• ${CLAUDE_SKILL_DIR}/references/safety-rules.md — branch protection, secret detection, destructive operation guards
• ${CLAUDE_SKILL_DIR}/references/error-recovery-playbook.md — conflict resolution, auth repair, detached HEAD, rebase recovery
• ${CLAUDE_SKILL_DIR}/references/github-review-apps.md — CodeRabbit, Copilot Review, Greptile, CodeQL, Qodo
• ${CLAUDE_SKILL_DIR}/references/claude-github-platforms.md — platform capabilities across Claude Code, Cursor, Windsurf, and others