Requesting a way to sync instructor changes to all student repositories....

[frohro]

🏷️ Discussion Type

Bug

💬 Feature/Topic Area

Verification Help & Guidance

Hi everyone,

This really bugs me. I want to make life easier for my students. When I want to update their repos with an assignment change or something, I find it very difficult to propagate the fix I make to the students. At the moment, I am using a script using rsync and git/clone to do it, but it is painful. I don't know how any instructor uses GitHub Classroom without this feature. It would be nice if I could just do one git push. It seems like it would be possible to add an 'instructor branch' to Classroom repos that the instructor can push to at any time. Students can git merge instructor to pull in updates, and Classroom auto-merges non-conflicting files on push.
How is everyone dealing with this? I am new to GitHub Classroom.
Thanks,
Rob

[github-actions[bot]]

💬 Your Product Feedback Has Been Submitted 🎉

Thank you for taking the time to share your insights with us! Your feedback is invaluable as we build a better GitHub experience for all our users.

Here's what you can expect moving forward ⏩

• Your input will be carefully reviewed and cataloged by members of our product teams. 
  • Due to the high volume of submissions, we may not always be able to provide individual responses.
  • Rest assured, your feedback will help chart our course for product improvements.
• Other users may engage with your post, sharing their own perspectives or experiences. 
• GitHub staff may reach out for further clarification or insight. 
  • We may 'Answer' your discussion if there is a current solution, workaround, or roadmap/changelog post related to the feedback.

Where to look to see what's shipping 👀

• Read the Changelog for real-time updates on the latest GitHub features, enhancements, and calls for feedback.
• Explore our Product Roadmap, which details upcoming major releases and initiatives.

What you can do in the meantime 💻

• Upvote and comment on other user feedback Discussions that resonate with you.
• Add more information at any point! Useful details include: use cases, relevant labels, desired outcomes, and any accompanying screenshots.

As a member of the GitHub community, your participation is essential. While we can't promise that every suggestion will be implemented, we want to emphasize that your feedback is instrumental in guiding our decisions and priorities.

Thank you once again for your contribution to making GitHub even better! We're grateful for your ongoing support and collaboration in shaping the future of our platform. ⭐

[syedsafeer]

Hi @frohro,
You've touched on a very common pain point. Currently, GitHub Classroom doesn't have a native 'one-click' sync feature for active assignments.
The most common workaround used by instructors is the 'Upstream Remote' method. You can ask your students to run these commands to pull your latest fixes:

1. git remote add upstream [Link-to-Template-Repo]
2. git pull upstream main (or your branch name)

Alternatively, some advanced users use the GitHub Classroom CLI or custom GitHub Actions to automate this. Your 'instructor branch' idea is excellent and would be a great feature I'd suggest posting it in the GitHub Feedback section as well

[frohro]

Thanks for the reply. I'm a bit worried that students will forget to pull the upstream and possibly encounter merge conflicts. Here is a table comparing my present method, which I'm not entirely happy with, either.

	Your sync_student_repos.sh	Upstream remote
Student action required	git pull (already habitual)	git pull upstream main (extra step, students forget)
Protects student work dirs	Yes — rsync excludes lab1/, journal/, etc.	No — pulls everything from template, risks conflicts
Instructor control	You push when ready, students get it	Students pull when they remember
Merge conflicts	Rare — you're pushing to their origin	More likely — template files vs student modifications
Setup per student	None	Each student must run git remote add correctly

Here is my script in case anyone is interested. It would need to be modified for another professor's class, but it gives the idea what I'm doing now.

#!/bin/bash
# sync_student_repos.sh
# Syncs all instructor-managed files from CPTR480_Template into every student
# repo in the GitHub Classroom org. Run this after pushing changes to the template.
# All repos are processed in parallel — typically completes in ~15 seconds.
#
# Usage:  ./sync_student_repos.sh [optional commit message]
#
# Student-owned directories (lab1-10, assignment1-2, journal) are never touched.
# Submodule directories are excluded — only .gitmodules is synced.

set -euo pipefail

ORG=WWU-CPTR480-2026
TEMPLATE_DIR=/home/frohro/Classes/Real_Time_Systems/2026/CPTR480_Template
LOG=/home/frohro/Classes/Real_Time_Systems/2026/sync_log.txt
MSG="${1:-sync from instructor template $(date +%Y-%m-%d)}"

# Directories that belong to students — never overwrite their work
STUDENT_DIRS=(lab1 lab2 lab3 lab4 lab5 lab6 lab7 lab8 lab9 lab10
              assignment1 assignment2 journal)

# Submodule content directories — managed by .gitmodules, not by file copy
SUBMODULE_DIRS=(Pico_Debug_Stack logicanalyzer yapicoprobe Intro-to-CAD-2026)

# Files at the repo root that should never be copied to students
ROOT_EXCLUDES=(sync_student_repos.sh sync_log.txt nohup.out)

# Build rsync --exclude flags
EXCLUDES=(--exclude='.git' --exclude='.git/')
for d in "${STUDENT_DIRS[@]}" "${SUBMODULE_DIRS[@]}"; do
  EXCLUDES+=(--exclude="$d/")
done
for f in "${ROOT_EXCLUDES[@]}"; do
  EXCLUDES+=(--exclude="$f")
done

echo "=== sync started $(date) ===" | tee "$LOG"
echo "    message: $MSG" | tee -a "$LOG"
echo "" | tee -a "$LOG"

# Process one repo; called in parallel via xargs below
sync_one() {
  local repo="$1"
  local out=""

  # Build excludes inside the function (arrays don't survive xargs subshells)
  local EXCL=(--exclude='.git' --exclude='.git/')
  for d in lab1 lab2 lab3 lab4 lab5 lab6 lab7 lab8 lab9 lab10 \
            assignment1 assignment2 journal \
            Pico_Debug_Stack logicanalyzer yapicoprobe Intro-to-CAD-2026; do
    EXCL+=(--exclude="$d/")
  done
  for f in sync_student_repos.sh sync_log.txt nohup.out; do
    EXCL+=(--exclude="$f")
  done

  # Re-invite student if they lost collaborator access.
  # Strip the assignment slug prefix to get the GitHub username.
  local student
  student=$(gh api "repos/$ORG/$repo/collaborators" --jq '.[].login' 2>/dev/null \
    | grep -v "^frohro$" | head -1)
  if [[ -z "$student" ]]; then
    student="${repo#cptr-480-github-classroom-setup-}"
    if gh api --method PUT "repos/$ORG/$repo/collaborators/$student" \
        -f permission=push --silent 2>/dev/null; then
      out="(re-invited $student) "
    else
      out="(WARNING: could not re-invite $student) "
    fi
  fi

  local CLONE_DIR
  CLONE_DIR=$(mktemp -d)

  if ! git clone --quiet --depth 1 "git@github.com:$ORG/$repo.git" "$CLONE_DIR" 2>/dev/null; then
    echo "$repo ... ${out}✗ clone failed"
    rm -rf "$CLONE_DIR"
    return
  fi

  rsync -a "${EXCL[@]}" "$TEMPLATE_DIR/" "$CLONE_DIR/"

  cd "$CLONE_DIR"
  git add -A

  if ! git diff --cached --quiet; then
    local CHANGED
    CHANGED=$(git diff --cached --name-only | tr '\n' ' ')
    git commit --quiet -m "$MSG"
    if git push --quiet; then
      echo "$repo ... ${out}✓ pushed [$CHANGED]"
    else
      echo "$repo ... ${out}✗ push failed"
    fi
  else
    echo "$repo ... ${out}already up to date"
  fi

  cd /tmp
  rm -rf "$CLONE_DIR"
}

export -f sync_one
export ORG TEMPLATE_DIR MSG

# Launch all repos in parallel (up to 15 at once), collect output atomically
REPOS=$(gh repo list $ORG --limit 50 --json name -q '.[].name' 2>/dev/null | grep '^cptr-')
RESULTS=$(echo "$REPOS" | xargs -P 15 -I{} bash -c 'sync_one "$@"' _ {})

echo "$RESULTS" | tee -a "$LOG"

echo "" | tee -a "$LOG"
echo "=== sync complete $(date) ===" | tee -a "$LOG"

Wouldn't it be nice if there were a way to do this that was really good? I can't imagine that an instructor never needs to edit student repos if he/she is using them as I am, where I have assignments there.

Again, thanks for the great reply.

Rob

[syedsafeer]

@frohro,
Thank you for sharing such a detailed comparison and your script! Your 'Push-based' approach is actually a very clever solution to the biggest flaw in the Upstream method: student negligence.

Using rsync with parallel processing is an efficient way to handle mass updates without manual intervention. It’s a great contribution to this thread and will definitely help other instructors who find the 'Pull' method too unreliable for large classes. We can only hope the GitHub Classroom team considers building a native sync feature inspired by this logic