Start here: this week

Final assignment tutorial

Everything about the final assignment, in order: what it is, every command, how the cap01 notebook connects to it, how you hand it in, and how you read your score. The guide says what each piece is for. This page says what to type.

The final assignment is your research assistant. It is graded on a private question set and earns the certificate. It is separate from the Gecko capstone, the store project you present on Friday 2 October, which lives in its own repository. Nothing on this page is about that one.

The whole path

• Keep your course folder up to date: the sessions and the cap01 notebook live there.
• From the course folder, create your repository beside it: uv run bootcamp final new ../my-final-assignment.
• In it, run uv sync once, then commit uv.lock.
• Publish it as a public repository: gh repo create my-final-assignment --public --source . --push.
• Point your assistant at the repository's AGENTS.md (how).
• Practise: uv run pytest and uv run bootcamp final grade.
• Put a real model in .env, so your agent can do more than refuse.
• After each session, add that session's piece to your repository (section 7).
• Keep docs/ISSUES.md ranked, and copy its top three rows into the cap01 notebook's cap01-e5.
• Commit and push, then hand in: uv run bootcamp final submit --github <you>.
• Read your score in finals/<you>/result.json in the submissions repository.

bootcamp final is the new name for bootcamp capstone. Both work, with the same options.

1. What you are building

2. Where everything lives

Three places. The repository is yours; the tests and the grader are the course's.

How your repository reaches the course's grader. bootcamp final new pins the course package in pyproject.toml to the exact course commit your course folder holds, and uv sync records it in uv.lock. uv run bootcamp final grade and submit are that package's commands, running on your agent. So the test is always the course's, and the code under test is always yours.

Updating the course is your call. Nothing changes behind your back. When you want a newer course:

uv lock --upgrade-package dev3pack-bootcamp-ai-engineering
uv sync
git add uv.lock && git commit -m "Update the course package" && git push

3. The pieces, and which one judges your agent

Only one of them judges your agent: the private grader.

There is no defence for the final assignment. Session 15 is where you present the Gecko capstone; the final assignment is judged only by the private set.

The numbers, exactly.

A pass needs a score of at least 30% and every critical question. On the private set the second gate is the one that decides: any pass is at least 40%.

4. Create your repository

In your course folder:

git pull
uv sync
uv run bootcamp final new ../my-final-assignment
cd ../my-final-assignment

If you use the projects or agents extras, name them as in today's class, for example uv sync --extra projects --extra agents. A bare uv sync removes extras you did not name.

What final new does:

• It creates ../my-final-assignment beside the course folder. Give it a folder inside the course folder and it refuses.
• It copies the template and the six documents in data/corpus/.
• It pins the course package to the exact course commit your course folder holds, so your agent always runs on the same course code.
• It makes one commit on main. It never pushes.

It prints the next commands.

5. Sync once, commit uv.lock, and publish

In my-final-assignment:

uv sync
git add uv.lock
git commit -m "Lock the course package"

Do this now, not later. uv sync creates uv.lock, and final new did not commit it, because it did not exist yet. submit reads uv.lock to record which course commit your agent ran on, and it refuses a repository with anything uncommitted. Skip this and, on the day you submit, you get:

your repository has changes that are not committed:
    ?? uv.lock

The fix is the same whenever it happens: git add uv.lock, commit, push.

Publish it. You need the GitHub CLI, signed in with gh auth login (as in handing work in):

gh repo create my-final-assignment --public --source . --push

This creates the public repository, sets it as origin, and pushes both commits. Public matters: your submission links to your code.

Without gh, in your browser:

1. Open github.com/new.

2. Name it my-final-assignment. Choose Public. Add no README, no licence and no .gitignore: your repository already has them.

3. Click Create repository. Then, in your terminal:

   git remote add origin https://github.com/<you>/my-final-assignment.git
   git push -u origin main
   

Never drag the folder into GitHub's upload page. That route ignores .gitignore, so it can upload your .env.

Open the Actions tab on GitHub. CI runs the tests and the practice grader on every push, on the fake model, with no key.

Point your assistant at AGENTS.md

Your repository has an AGENTS.md at its root: what the repository is, what your assistant may and may not do in it, and the commands. Most assistants read it by themselves; Claude Code reads the CLAUDE.md beside it, whose first line imports it. Give your assistant the rules has the table for every assistant, and the first prompt to paste.

Made your repository before 30 September? It has no AGENTS.md yet. Copy the two files from the course folder:

cp ../dev3pack-cohort-2026-09/capstone-template/AGENTS.md ../dev3pack-cohort-2026-09/capstone-template/CLAUDE.md .
git add AGENTS.md CLAUDE.md && git commit -m "Tell my assistant the rules" && git push

(Use your own course folder's name if it is not dev3pack-cohort-2026-09.)

6. Practise: the tests and the practice grader

In my-final-assignment:

uv run pytest
uv run bootcamp final grade

• uv run pytest prints 4 passed, 2 skipped, 3 xfailed. The xfailed ones are behaviours the starter agent does not have yet, each marked with the session that teaches it. When one starts passing, remove its xfail mark.
• uv run bootcamp final grade runs your agent on the 10 practice questions. With no .env it uses the offline fake model and ends with score: 3/10 (30%), NOT YET, and critical safety gate failed. That is the starting line: the fake model can only refuse, so the three refusal questions pass and nothing else can.
• The report goes to score_report.json, which is gitignored, so grading never leaves anything to commit.

Useful options:

Give your agent a real model. A real score needs one:

cp .env.example .env

ollama needs no key. It uses http://localhost:11434/v1 unless you set OLLAMA_BASE_URL. See a local model. .env is gitignored: never commit it and never paste it into a chat.

Run uv run bootcamp final grade again; the first line names the model it used. A real model can score differently on two runs of the same code, so write down which model produced each number.

7. What each session adds

bootcamp check chNN runs in the course folder. pytest and the grader run in your repository. The contract tests pass as shipped, because your agent starts as the course's pipeline: their job is to stay green while you change it.

The loop, every time you change something:

uv run pytest
uv run bootcamp final grade
git add -A
git commit -m "what you changed"
git push

Read git status before git add -A. It should never list .env.

8. The cap01 notebook, and how it connects to your repository

The notebook is not in your repository. It is in the course folder, and it runs and is handed in from there, like a session notebook:

# in the course folder
git pull
uv run jupyter lab units/en/unit2/capstone/notebook.ipynb
uv run bootcamp check cap01
uv run bootcamp submit cap01 --github <you> --push

What its five checks judge:

The connection is cap01-e5. Your issue list lives in docs/ISSUES.md, in your repository. Copy its top three rows into the notebook's issues cell, as rank, issue and impact, then run the check and hand the notebook in. When your ranking changes, update both.

So bootcamp check cap01 printing 4/5 as shipped is expected, and a green notebook means the contract can be met. Your agent is judged by the private grader, which runs on what your repository hands in.

9. Hand in the final assignment

The final questions are open. In my-final-assignment, finish the loop first: git status says "nothing to commit, working tree clean", and your last commit is pushed. Then:

export DEV3PACK_API_BASE=https://app.geckovision.tech
uv run bootcamp final submit --github <you> --dry-run
uv run bootcamp final submit --github <you>

<you> is your GitHub login, the one in your profile URL.

Before anything runs, it checks your repository: a commit, nothing uncommitted (uv.lock included), an origin on GitHub that is yours, and your last commit pushed. The submission links to that commit, so the code on GitHub has to be the code that answers.

Then three steps:

1. 1/3 the practice set, locally: your practice score and the model it ran on. Nothing leaves your machine. Read this line. If it says WARNING: this run uses the fake model, your agent will score 4/15 (27%) on the final set and fail both gates. Stop, set up .env (section 6), and run it again.
2. 2/3 the final questions: they come from the course app, with no answer keys. Your agent answers each one. A question that crashes or takes more than 120 seconds becomes a flagged refusal, and the run goes on.
3. 3/3 the bundle: it writes answers.json and submission.json, then opens a pull request to Gecko-Academy/dev3pack-submissions, under submissions/<you>/final/.

--dry-run does every check and both runs, writes the bundle to a temporary folder, prints both files, and opens no pull request. It still asks your model every final question, so it costs what a real run costs.

No gh? The command says so, keeps the bundle, and prints the steps to open the pull request in your browser.

You can submit again. Each new submission replaces the one before: your latest submission counts, not your best.

10. Read your score

submit does not print your final score: the answer keys never leave the course app, so nothing on your machine can compute it.

1. The pull request's check reads your bundle.
2. When it passes, the submissions repository merges the pull request.
3. A workflow sends your answers to the course app and commits what comes back.

Your score is at:

https://github.com/Gecko-Academy/dev3pack-submissions/blob/main/finals/<you>/result.json

A new submission overwrites the file. If your pull request shows Merged and the file is not there, tell the instructor; submitting again will not make it appear sooner.

The certificate is issued by the course, signed, and separately from this file. The final assignment page shows how anyone can verify one.

11. Reading the grader

Each question passes only when every gate on it passes. The last column of the grader's output lists the gates that failed. Reading the grader — opens with week 2, in the guide, has every gate, its usual cause, and the session that teaches the fix.

The verdict: PASSED needs a score of at least 30% and every critical question. 5 of the 10 practice questions are critical: the 3 refusals, the adversarial one, and one grounded one. 6 of the 15 private questions are critical. A practice report is never credential evidence; only the private set certifies.

12. Your README, for the showcase

The README final new wrote tells you how to start. When your agent runs, replace it with yours, in the order a reviewer reads it:

Never in it: an API key, your .env, anything from the private question set, or another student's code without a "Credits" line naming it.

13. Rules

No solutions are published for the final assignment, and the private set stays private: a system tuned on the cases it is graded on measures its own homework.

Resources

Troubleshooting

Every refusal below is a message the command prints; each one means nothing was handed in. After any fix that changes a file, commit and push before you submit again: submit hands in the code that is on GitHub.

Creating the repository

Grading and the model

Submitting

Stuck on something not here? Ask the course from your assistant. See search the course from your assistant.

Already started the research assistant somewhere else? A repository made with bootcamp capstone new is the same thing under the older name: keep it, and every section here applies. A clone of the Capstone Project repository is the Gecko capstone's home, not the final assignment's: create your final assignment with section 4 and copy your agent.py, tests/ and docs/ across.