Fictional example · 24-hour campus hackathon · final pitch

MergeMate

Stop breaking main at 3 a.m. — pre-merge checks with results your whole team actually reads.

Team Nightshift (fictional) — built during the event, demoed live today

Problem

Hackathon teams lose demo time to broken merges

Four people push to one repo for 24 hours straight — the riskiest merges happen when everyone is most tired.
One broken merge to main an hour before judging can cost the whole demo.
Real CI is overkill to set up mid-event, so most teams run no checks at all and merge on hope.

Who it's for

Small teams sharing one repo under time pressure

Primary: hackathon teams

3–5 students, mixed git experience, merging every few minutes near deadlines. Today they either merge blind or make one person the human merge gate.

Also fits

Capstone and club project teams with the same shape: one shared repo, no CI budget, no time to configure anything.

Solution

A merge gate you install with one command

Three fast checks

Every merge to main runs build, lint, and a conflict-risk scan — under a minute, locally.

Plain-language results

"Your branch changes the same 12 lines as Priya's open branch" — not a 400-line log.

Zero config

npx mergemate init installs the git hook and the team dashboard. Nothing to host, nothing to sign up for.

Live demo

Break a branch on purpose, watch it get caught

Setup — run npx mergemate init in the team repo; the hook and dashboard appear. Notice: no config files written by hand.
Break it — commit a change that fails lint and overlaps a teammate's open branch, then try to merge.
Catch it — MergeMate blocks the merge and explains both problems in two sentences.
Fix and pass — apply the suggested fix, re-merge, and see the dashboard log the clean merge.

Fallback if the live run fails: this slide is the narrative, and a recorded run is on the demo machine.

Architecture

Everything runs locally — no server, no accounts

merge attempt on main — developer's machine
git pre-merge hook → MergeMate CLI (Node.js) — installed by init
check runner: build · lint · conflict-risk scan — runs in parallel, ~1 min budget
plain-language summary → static team dashboard — a local HTML page, shareable as a file

Honest scope: the dashboard is a static page regenerated per run; there is no hosted backend — that's a feature at a hackathon, not a shortcut.

What was hard

Three problems worth mentioning

Conflict-risk scan

We diff each open branch against the merge base and flag overlapping hunks. It's a heuristic, not a semantic merge — and we say so when it warns.

Readable failures

A small rule table maps the 20 most common build/lint errors to one-sentence explanations with the file and line up front.

Sub-minute checks

Checks run in parallel and reuse the last build cache; anything slower than 60 seconds gets skipped with a visible notice instead of blocking the team.

Results

We ran it on ourselves for the whole event

EXAMPLE DATA — fictional numbers for this sample deck

27

merge attempts checked during the 24-hour event (our own repo, single team)

4

broken merges blocked before they reached main — including one 40 minutes before this pitch

41s

median check time, within our one-minute budget

One team, one event — a proof of concept, not a study. That's the honest claim.

Next steps

What this project needs next

Language coverage — the check runner currently assumes a Node.js project; Python support is the most requested next target.
Better conflict signal — score overlap risk by hunk proximity instead of flagging any shared file region.
Real-world trial — run it with two or three other student teams next semester and measure what it catches.

Thanks

Broken merges are preventable — even at 3 a.m.

Repo: https://example.com/mergemate-repo (fictional URL for this example)
Team: nightshift@example.com (fictional contact)

Our ask: try it at your next hackathon and tell us what it missed.