Builder's playbook GitHub Copilot App Hackathon edition

Winning the
Hackathon

Ship more than any team in the room, using GitHub Copilot.
Prepare your agents in the evening. Let them build all night. Merge over coffee tomorrow. ☕
Julien Dubois  ·  github.com/jdubois  ·  julien-dubois.com
GitHub Microsoft

👋 Who am I?

Julien Dubois
☕ Java Champion 🏢 Microsoft / GitHub ⭐ JHipster 22k+ 🤖 AI × code
  • Principal Manager, Developer Relations @ Microsoft / GitHub
  • Creator of JHipster · 22,000+ ⭐
  • 200+ international talks (Devoxx, SpringOne, MS Build…)
  • Today: shipping real projects by managing AI agents

📊 My month with Copilot

One developer · ~30 days · real GitHub activity + Copilot usage data

759
commits authored
406
PRs merged (419 opened)
~443k
lines changed +347k / −96k
~14B
AI tokens / month *

Tokens by model · ~14B / month

Claude Opus 4.845%
GPT-5.3-Codex16%
GPT-5.513%
Gemini 3.1 Pro12%
Claude Haiku 4.510%
+6 more models4%

Tokens: 95% served from cache

95% cache reads
  • 13.3B cache reads · 113M fresh input
  • 90M output · 423M cache writes
  • ~14B tokens / month total
  • spread across 11 models

* Token usage extrapolated from 7 days of real Copilot data across all integrations (CLI, app, mobile, PR reviews); 95% is cache reads.

🚀 The mindset shift

You're not the developer, you're the manager now.

🧑‍✈️ You · the manager
🚀 Feature 1
the winning demo
🧩 Feature 2
more depth to win
🎨 UI
polish & landing
🏗️ Infra
deploy & plumbing

Many agents in parallel. You brief, review, merge.

You don't type faster. You ship wider.

🏁 The rules

⏱️ The constraint

  • 2 days, hard stop
  • You need to ship a real product
  • You can't code all night and still ship on time

⚡ Your advantage

  • You have GitHub Copilot
  • A fleet of agents in parallel, not one chat window
  • They keep building while you sleep
Same tools, same clock for everyone. The team that uses them best ships wider and wins.

🗓️ The 24-hour playbook

🌙 while you sleep
6pm10pm12am7am10am12pm
PrepScope it, brief your agents
LaunchSplit into parallel tasks, go
🌙 OvernightAgents build, test, open PRs
☀️ MorningMerge wins, drop the rest
Final pushPolish, integrate, demo-proof
🏁 ShipSubmit & present

Evening

2 hours of prep buys you 8 hours of unattended building.

Overnight

Agents work in parallel during the night. Your runway doubles.

Morning

Triage the overnight haul, merge the wins, re-brief for the day.

🛠️ Step 1: Prep your agents · evening

📜 Write it down · AGENTS.md

  • Set the house rules once
  • What you're building · conventions · how to build & test
  • Every agent reads it first, no re-explaining

✅ Give them a test harness

  • A real build + test command they can run
  • They verify their own work before reporting back
  • No tests = you can't trust the output

🛡️ Set guardrails

  • One branch / worktree per task
  • Small scope, clear goal
  • Nothing hits main without your review

🧩 Split the work

  • Break the build into independent pieces
  • One task each: two features, UI, infra
  • Parallel-ready = night-ready
Tip: the better the brief, the less you babysit at 2am.

🌙 Step 2: Let them build overnight · while you sleep

Kick off several agents at once. Each runs in a loop on its own branch/worktree: build, test, open a PR, pick up the next task. One agent repeats this loop many times before dawn.
🚀 Agent 1
Core feature: the thing that wins the demo
loop ×6 · 6 PRs
🧩 Agent 2
Second core feature, built in parallel
loop ×5 · 5 PRs
🎨 Agent 3
UI, polish & landing page
loop ×7 · 7 PRs
🏗️ Agent 4
Infrastructure: deploy, CI & data
loop ×4 · 4 PRs

☀️ Step 3: Review over coffee · morning

Your morning routine

  • Triage the overnight haul: tens of PRs
  • Merge the good ones fast
  • Drop or re-task what didn't land
  • Cherry-pick the good parts of the rest
  • Re-brief and relaunch for the day

Wake up to progress

Tens of PRs are waiting as every agent looped all night. The build moved while you didn't. Then the loop repeats: brief → build → review.

📋 The one-page playbook

1Write the house rules (AGENTS.md) before you start a single agent.
2No agent without a test harness: give it a build + test it can run itself.
3One task per agent. Small scope, clear goal, own branch.
4Run them in parallel: that's the whole point. Don't babysit one.
5Let them build overnight while you sleep.
6Review in the morning: merge wins, drop failures, re-task fast.
7Pick the right model for each task; save what works as reusable skills.
If there's one slide to screenshot, this is it.

⚠️ Watch out for

Scope creep

"Build the whole app" makes an agent wander.
Fix: one tight goal per task.

No tests, no trust

You can't read every line of tens of PRs.
Fix: harness first, green build before merge.

Giant PRs

A 2,000-line PR is impossible to review.
Fix: small, reviewable chunks.

Wrong model

A weak model won't solve the hard tasks; a strong one is slow and costly.
Fix: choose the right model for the job.
Most failed runs aren't the agent's fault. They're a briefing problem.
That's the playbook.

Now go build. 🚀

Prep in the evening · build all night · merge over coffee.
Brief them well, run them wide, and out-ship the room.
🌐 julien-dubois.com  ·  𝕏 @juliendubois  ·  🐙 github.com/jdubois