W4D5: Exam, project grading, feedback and certificates

Last day. No live exam, no new game systems, just the admin side of finishing a course properly plus a long unscripted segment where Lucian pushes the Duck Invaders build through Apple’s App Store Connect and TestFlight. If you’re wondering what you actually get at the end of these 64 hours — a test, a graded project, a certificate — this is the session that spells it out. It’s also the most honest one, because half of it is Lucian asking the class what was wrong with the course and reading the answers out loud.

What’s covered

The skill assessment

• No exam on the day. The in-person version of this course would have run a live 20-30 minute exam here; the remote version doesn’t.
• You email [email protected] (or ping Discord) and get a personalised link to the test. Timed, so there’s no room to Google answers mid-question.
• Format: around 100 questions, mix of multiple choice and free typing, difficulty in random order rather than escalating. Standard advice applies — skip what you don’t know and get to question 100.
• Designed so a perfect score is basically impossible. Lucian says 100/100 means you cheated, and even 97 looks suspicious.
• No fixed deadline. Take it three weeks from now if you want. He recommends within a week, mostly for the sense of closure.

Project grading

• Grading is subjective and he says so directly.
• Scope expectation: roughly 15 hours of work. Main menu with one button, one level, that’s it. No particle systems required, no sound required.
• The phrase he keeps repeating: breadth-first, not depth-first. A tiny game where every part exists beats a gorgeous main menu attached to nothing.
• Host it on GitHub Pages as a WebGL build. Public repo required for Pages to work, but you can copy the code into a private repo afterwards if you want to keep developing it.
• Using ChatGPT or similar to write parts of it is fine. His view: these are tools, requirements will get harder as the tools get better, banning them is the wrong move.

Certificates and scoring

• Test and project are scored out of 100 each, averaged. You need at least 50 on each.
• If you pass both, the score gets shown. If you only pass one, only that score appears. If you pass neither, you still get a certificate of completion with no score on it.
• There’s no failing grade. His reasoning: if you didn’t pass, you know what to do, and it’s not his job to send you back to class.

Feedback round

• Open chat: what would you change, what’s lacking, what did you like.
• The main criticism that lands: less theory and more practical examples in the two C# days. He agrees, estimates three out of ten topics in those sessions didn’t get enough worked examples, and points out week three’s live coding was partly there to compensate.
• A student suggests team projects. Lucian likes it, notes it’s tricky remotely because one person dropping out drags the rest down, and says there’s a 95% chance a third team-based component gets added later.
• Another suggestion: push people into the Google Meet rather than the YouTube stream so there’s actual interaction.

The education rant

• A long tangent on why school produces negative associations for most people and why that’s not necessary.
• Walkthrough of the five-pillar manifesto behind rockstart.ai: legitimacy (tutors who’ve worked in the field), free and complete access with no premium tier, pull-based teaching over push, critical thinking over memorisation, hands-on practice over homework, self-growth over comparison to peers, humour over authority, efficiency, and self-replication.
• The one he keeps circling back to: measure a student against who they were a year ago, not against the person sitting next to them.

Shipping to iOS

• The part that’s actually technical. Registering an app ID and bundle identifier, picking capabilities, then the certificate dance: generating a signing request through Keychain Access, creating an Apple Distribution certificate, generating a provisioning profile, wiring it into Unity’s iOS player settings.
• Building to Xcode, setting version and build number, product archive, validate before distributing (cheap insurance against rejection).
• Uploading through App Store Connect, internal vs external TestFlight groups, why the Xcode “TestFlight internal only” option blocks external testers, and the fix.
• Export compliance questions, submitting for beta review, and the public link you eventually get to hand to testers.
• Fastlane gets a mention as the thing that automates all of this. Roughly a week of setup, then it manages certificates and builds for you from CI.

Timestamps

• 00:00:30 — Opening, group photo request, and why today is the most relaxed session
• 00:03:00 — Why there’s no live exam, and how the remote assessment works instead
• 00:07:00 — Deadlines: there aren’t any real ones, but aim for next Friday
• 00:12:00 — Hosting your project on GitHub Pages as WebGL, public vs private repos
• 00:16:00 — Test format: multiple choice plus free text, unique per student, timed
• 00:22:00 — Scoring rules, the 50-point floor on each component, and the certificate
• 00:27:00 — 100 questions, random difficulty, and why a perfect score reads as cheating
• 00:33:00 — Tangent on school, stress, and how education should feel
• 00:40:00 — Project scope: main menu, one level, breadth-first not depth-first
• 00:45:00 — Using LLMs on your project, and why requirements will get harder instead
• 00:52:00 — Team projects: good idea, wrong course, likely a third component later
• 01:00:00 — Feedback: pace, style, and the call for more practical examples in the C# days
• 01:12:00 — What students liked, tutorial hell, and the bird’s-eye-view argument
• 01:20:00 — The two-minute call, survey links, and rockstart.ai’s plans
• 01:26:00 — The five pillars of the education manifesto, walked through one by one
• 01:42:00 — App Store Connect: registering the bundle ID and app capabilities
• 01:50:00 — Adding mobile auto-fire to Duck Invaders with a fire-rate cap
• 02:00:00 — Certificates and provisioning profiles, generating a CSR in Keychain Access
• 02:15:00 — Xcode signing, product archive, and validating before upload
• 02:30:00 — TestFlight internal vs external groups, export compliance, build numbers
• 02:45:00 — Public links, final thoughts, and the cowboy slide

What you take away

A clear path to actually finishing: email for the test, build a small complete game, host it on GitHub Pages, submit, get a certificate. Also a working knowledge of the iOS release pipeline, which is the one platform where the paperwork is worse than the build. Watching someone stumble through Apple’s certificate maze in real time, Googling the steps, is more useful than a clean tutorial that hides the friction.

The mobile fire-rate fix is the only code written here, and it’s deliberately quick and dirty:

private const float MIN_FIRE_INTERVAL = 0.1f;
private const float MOBILE_FIRE_INTERVAL = 0.2f;
private float timeLastFired;

void Update()
{
    if (Time.time - timeLastFired < MIN_FIRE_INTERVAL) return;

    if (Application.isMobilePlatform)
    {
        StartFire();
        ProgressFire();
        StopFire();
        timeLastFired = Time.time;
        return;
    }

    // existing mouse input path
}

His own comment on it: “it’s not like the best way of doing it, but you kind of get the grasp of how stuff works when you’re on a deadline.” The balance reasoning is worth keeping — on desktop you can spam-click to about 10 shots a second, so the mobile auto-fire gets throttled to five so touch players aren’t overpowered.

Who should watch this

Anyone who wants the certificate needs the first hour, because that’s where the submission process, the grading rules and the deadlines actually get explained. The second half is for anyone who plans to put a Unity game on iOS and hasn’t dealt with Apple’s signing system before. If you only came for Unity techniques, this one’s skippable apart from the TestFlight segment.