Key takeaways
- A hackathon after a workshop is where habits form: two days of real work with agents, with the trainer still in the room.
- Preparation decides the outcome – pick backlog items in advance that are valuable, small enough and independent of each other.
- House rules keep it honest: everything goes through pull requests, CI and human review, and no production secrets are in reach.
- Judge mergeable work, test evidence and lessons for the team, not the flashiest demo.
Why run a hackathon after a workshop
A workshop teaches the method. Then everyone goes back to deadlines, and the new method competes with old habits under time pressure. A hackathon closes that gap: two protected days in which the only job is to deliver real backlog items with coding agents, while someone who knows the tools is around to help.
It also produces evidence. After two days, the team knows which kinds of tasks agents handle well in this codebase, where the context file is still missing something and how long review really takes. That is more useful for planning than any vendor claim.
Classic hackathons reward bold prototypes that never get merged. This format deliberately does the opposite.
Three weeks before: preparing the backlog
The product owner and the tech lead select candidate items. Good candidates are:
- Valuable – someone wants them shipped, so the result won't rot on a branch.
- Bounded – a team of three can finish one in a day, with review.
- Independent – teams don't block each other on the same files.
- Testable – acceptance criteria exist, ideally with a way to check them automatically.
Mix the types: a small feature, a bug with clear reproduction, missing tests for a critical module, a migration nobody wanted to do, an accessibility pass over a few screens. Write each item up as a short spec; the spec-driven development workshop explains a format that agents follow well.
In parallel, IT checks that licences, repository access and the model API work for everyone, and that a staging environment and test accounts exist. For mobile teams: Macs with Xcode 26 for iOS builds, emulators for Android, and a CI pipeline that can push builds to TestFlight internal testing or the Play Console's internal testing track.
Talk to an AI Code Engineer about your agentic coding workshop.
In a free call we look at your team, your codebase and your goals and suggest a workshop format that fits – remote or on-site, in English or German.
Teams and roles
Teams of three or four work best. Each team needs:
| Role | Responsibility |
|---|---|
| Driver | Runs the agent session, keeps the plan current |
| Navigator | Reads plans and diffs, stops the agent when it drifts |
| Tester | Checks acceptance criteria, tries edge cases on device or emulator |
| Product voice (optional) | Answers "what should happen here?" without a meeting |
Roles rotate every few hours. Mix experience levels deliberately: someone who used agents a lot during the workshop alongside someone who barely did. Designers, QA engineers and product managers make good team members – an agent-assisted team gets further when the person who knows what "done" looks like sits at the table.
House rules for agent work
- Every change goes through a pull request, CI and a review by someone outside the team.
- The agent plans before it codes, and the plan is visible in the pull request description.
- No production secrets and no production data in reach of any agent session.
- Signing configuration, entitlements, manifests and payment code are off-limits unless the item is about them, and then they get an extra reviewer.
- If an agent run goes nowhere for half an hour, stop and re-plan – write down why it failed.
- Every team keeps a short log: what worked, what didn't, what the context file should say.
The two-day schedule
| When | What |
|---|---|
| Day 1, morning | Kick-off, house rules, teams pick items, first plans reviewed by the facilitator |
| Day 1, midday | Short stand-up: blockers, context file gaps, shared tricks |
| Day 1, afternoon | Implementation; first pull requests opened and reviewed across teams |
| Day 1, end | Each team states what will be mergeable tomorrow – and what won't |
| Day 2, morning | Finish, test, address review comments; builds to internal testers where relevant |
| Day 2, early afternoon | Feature freeze, final reviews |
| Day 2, late afternoon | Demos on real builds, judging, retrospective |
A remote version works too, but schedule it as two shorter days with a fixed video stand-up every few hours. Our comparison of remote and on-site formats covers the trade-offs.
Judging that rewards mergeable work
Make the criteria public on the first morning. A simple scheme:
- Mergeable – is the pull request approved and green, or close to it?
- Tested – are acceptance criteria covered by tests or a documented manual check?
- Reviewable – could a colleague understand the change from the description and diff alone?
- Lessons – what did the team learn that improves the context file or the team rules?
- Value – how much does the result matter to users or the business?
A team that delivered one small, clean, merged change and a sharp log of what went wrong beats a team with an impressive demo on an unreviewable branch.
After the hackathon
- Merge what is mergeable within a week, or close it deliberately.
- Collect the team logs and update the context file, the team rules and the permission settings in one reviewed pull request.
- Write down which task types agents handled well in this codebase – it guides what you hand to agents next.
- If builds went to internal testers, follow the feedback through like any other release.
We facilitate hackathons on-site or remotely, in English or German, usually after a workshop such as the one in our sample agenda. For mobile teams, our AI Code Engineers can set up the pipeline to internal testing beforehand so that day two ends with real builds on real phones – the playbook on shipping iOS and Android with one agentic workflow shows the setup. Book a free call to plan the format with us.
Hackathon preparation checklist
- Candidate items are selected, written up as short specs and checked for overlaps.
- Licences, repository access and the model API work for every participant.
- A staging environment and test accounts exist; no production secrets are needed.
- CI runs on every pull request, and reviewers outside each team are assigned.
- Mobile builds can reach TestFlight internal testing or the Play internal testing track.
- Judging criteria and house rules are written down and shared on day one.
- A date for merging and the retrospective follow-up is fixed.
Frequently asked questions
Does an agentic coding hackathon need a workshop first?
It helps a lot. Without a shared method, teams spend the first day on basics. A workshop a week or two before – or an extended first morning – gives everyone the same starting point.
What if nothing gets merged?
Then the logs are the result: they show what blocks agents in your codebase, whether that is missing tests, unclear architecture or slow review. That is valuable, but good item selection and the house rules usually make sure several items land.
Should non-developers take part?
Yes, as product voice or tester. They speed up decisions and see first-hand what agents can and cannot do, which improves planning later.
Can you facilitate our hackathon?
Yes. We help select items, prepare the environment, run the two days and the retrospective, remotely or on-site, in English or German.
Free, 15 minutes, no obligation
Plan your agentic coding workshop with us.
Our AI Code Engineers run hands-on workshops on Claude Code, OpenAI Codex, Cursor and AI app builders – and ship apps to the App Store and Google Play every week. Tell us about your team.
AI tools, store policies and requirements change quickly – always check the current documentation of the tools and stores you use. This article is independent advice and not affiliated with or endorsed by Apple, Google, Anthropic, OpenAI or any other company or product mentioned; all trademarks belong to their owners.