agentleFS
jsboigejsboige/CoursIA/.claude/skills/review-student-prs/SKILL.md

review-student-prs

Skill17 starsChanged 2 days agoMITView on GitHub

Review and merge student exercise PRs during TP sessions. Arguments: <repo-url> [--class <class-id>] [--timeslot <HH:MM-HH:MM>] [--dry-run]

The file

Show its rules and text

We split this skill into the rules it gives an agent

24 rules. About 0 are common, 22 are distinctive, and 2 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈22

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 2

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  • could be automatic: a setting could enforce it
  1. Distinctive:

    Filter by timeslot: - Only PRs created within the authorized submission window

    line 24
  2. Very specific:

    If available, match against inscription spreadsheet (G:\Mon Drive\MyIA\Formation\ECE\2026\)

    line 28
  3. Distinctive:

    Check that exercise cells have been filled (not empty or placeholder)

    line 47
  4. Distinctive:

    Verify code is syntactically correct

    line 48
  5. Distinctive:

    Check markdown cells for explanations if required

    line 49
  6. Distinctive:

    If the exercise cell was solved by uncommenting provided solution code: flag as TRIVIAL

    line 61
  7. Distinctive:

    If this was due to solutions being provided in comments (our error): accept but note it

    line 62
  8. Distinctive:

    If the student wrote original code different from any example: mark as ORIGINAL

    line 63
  9. Distinctive:

    Add brief commentary on the approach used

    line 110
  10. Distinctive:

    Add a NEW exercise cell after the newly created example

    line 114
  11. Distinctive:

    Not directly derivable from the example above

    line 117
  12. Distinctive:

    Add appropriate markdown instructions for the new exercise

    line 120
  13. Distinctive:

    If multiple students solved the same exercise across PRs:

    line 123
  14. Distinctive:

    Keep the most pedagogically valuable solution as example

    line 124
  15. Distinctive:

    Remove redundant examples that don't add new insight

    line 125
  16. Distinctive:

    Ensure the notebook flow remains coherent

    line 127
  17. Distinctive:

    If a notebook accumulates too many examples (>3 consecutive examples on same concept):

    line 129
  18. Distinctive:

    Keep the 2 most distinct/illustrative ones

    line 130
  19. Distinctive:

    Timing: Run between classes (e.g., noon-2pm) so afternoon class gets fresh exercises

    line 160
  20. Distinctive:

    Conflict resolution: If two PRs modify the same notebook, merge the first, rebase the second

    line 162
  21. Distinctive:

    Security: Never execute untrusted code outside the notebook sandbox

    line 163
  22. Very specific:

    Backup: Create a local branch backup before merging: backup/pre-merge-<date>

    line 164
  23. Distinctive:

    No force push: All merges are regular merges or fast-forwards

    line 165
  24. Distinctive:

    No personal data: never copy student names or e-mails from these classeurs into the repository, a PR or a public comment.

    line 187

≈ “Common” is an estimate: at least 1 in 5 of the 372,429 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Review Student PRs

Review, validate, and intelligently merge student exercise PRs submitted during TP sessions.

Target: $ARGUMENTS

Arguments

  • repo-url: GitHub repository URL (e.g., https://github.com/jsboigeECE/2026-ECE-Ing4-Fin-IA-Projet1-Gr01)
  • --class <class-id>: Class identifier (e.g., Gr01, Gr02, Gr03)
  • --timeslot <HH:MM-HH:MM>: Authorized submission window (e.g., 08:00-12:00). PRs outside this window are flagged
  • --dry-run: Review only, no merge or commit

Process

Phase 1 - Discovery & Identification

  1. Fetch open PRs from the target repo using gh pr list
  2. Filter by timeslot - Only PRs created within the authorized submission window
  3. Identify students:
    • Parse PR title/body for student name, group, notebook claimed
    • Cross-reference GitHub username with submission account
    • If available, match against inscription spreadsheet (G:\Mon Drive\MyIA\Formation\ECE\2026\)
  4. Flag anomalies: PRs outside timeslot, duplicate claims on same notebook, unknown accounts
  5. Check each delivery against the group's reservation (MANDATORY before any conversion in Phase 4, teacher sign-off 2026-11-10). The reservation lists stop two groups from reserving the same exercise; they cannot stop a group from delivering an exercise it did not reserve. For each PR, once the group is identified (step 3) and the delivered notebook and exercise numbers are known, run the private read-only script of the cohort's reservation tools:
    conda run -n mcp-jupyter python "G:\Mon Drive\MyIA\Formation\EPF\2027\outils-reservation-tp\verifier_rendu.py" \
        --classeur <IA2-Min1|IA2-Min2|MIS|APP3|MIN52> --groupe <Gnn> --carnet <repo path of the notebook> --exercices <1,2,3>
    • rc=0: every delivered exercise is reserved by this group. Proceed.
    • rc=1: at least one exercise is COLLISION (reserved by another group) or HORS-RESERVATION (reserved by nobody in this notebook). Do not convert that exercise. Record the gap in the report and put the decision to the teacher (user question registry). The script also lists the group's reservations in other notebooks, which shows a renamed notebook or a delivery moved from another notebook.
    • rc=2: the classeur could not be read. This is never an OK: repair the access first.
    • Also check on main that the delivered exercise is not already a guided example credited to someone else: git show origin/main:<notebook> | grep -o 'Exemple guidé[^"]*'.

Phase 2 - Code Review

For each valid PR:

  1. Fetch PR diff using gh pr diff <number>
  2. Identify modified notebooks and changed cells
  3. Validate exercise completion:
    • Check that exercise cells have been filled (not empty or placeholder)
    • Verify code is syntactically correct
    • Check markdown cells for explanations if required
  4. Execution validation (MANDATORY - do not skip):
    • Checkout PR branch locally
    • Execute the modified exercise cell(s) and all prerequisite cells
    • For Python notebooks: python scripts/notebook_tools/notebook_helpers.py execute <path> --verbose
    • For .NET notebooks: use MCP cell-by-cell execution
    • Record execution results (pass/fail, output, errors)
    • If cell fails to execute: mark as PARTIAL, note the error
    • If error is environment-only (missing package on student machine but code is correct): accept with note
    • If error is code logic: mark as INVALID
  5. Detect copy-paste / uncommenting:
    • Compare student's code against the "Exemple guide" in the same notebook
    • If the exercise cell was solved by uncommenting provided solution code: flag as TRIVIAL
    • If this was due to solutions being provided in comments (our error): accept but note it
    • If the student wrote original code different from any example: mark as ORIGINAL
  6. Quality assessment (per exercise):
    • Code correctness (executes without error)
    • Code originality (ORIGINAL vs TRIVIAL vs COPY)
    • Code quality (reasonable approach, variable naming, structure)
    • Explanation quality (if markdown present)
    • Score: VALID / PARTIAL / INVALID

Phase 3 - Report Generation

Generate a correction report in reports/corrections/ (gitignored):

reports/corrections/YYYY-MM-DD_<class-id>_review.md

Report format:

# TP Review - <date> - <class-id>

## Summary
- PRs reviewed: N
- Valid exercises: N (+0.5 pts each)
- Partial: N (manual review needed)
- Invalid: N

## Per-Student Results

### <Student Name> (GitHub: @username)
- **PR**: #<number> - <title>
- **Notebook**: <notebook-name>
- **Timeslot**: <created-at> (VALID/LATE)
- **Exercises**:
  | Exercise | Status | Score | Notes |
  |----------|--------|-------|-------|
  | Ex 1     | VALID  | +0.5  | Clean implementation |
  | Ex 2     | PARTIAL| 0     | Missing explanation |
- **Total bonus**: +X.X points

Phase 4 - Intelligent Merge

For each VALID exercise whose reservation check (Phase 1, step 5) returned OK, or which the teacher has explicitly cleared (skip if --dry-run):

  1. Transform exercise result into example:
    • The student's completed exercise cell becomes a new example cell
    • Rewrite the preceding markdown to frame it as "Example - <topic>" instead of "Exercise"
    • Add brief commentary on the approach used
    • Preserve the student's code as-is (it's their contribution)
  2. Create replacement exercise:
    • Add a NEW exercise cell after the newly created example
    • The new exercise must be:
      • Different from the one just solved (not a trivial variant)
      • Not directly derivable from the example above
      • At a similar difficulty level
      • Related to the same topic/concept
    • Add appropriate markdown instructions for the new exercise
  3. Curate redundancy:
    • If multiple students solved the same exercise across PRs:
      • Keep the most pedagogically valuable solution as example
      • Remove redundant examples that don't add new insight
      • Credit every correct, independent solution on the kept example, the later one included (co-credit in the example heading, each with its PR number). A redundant solution loses its cell, never its credit.
      • Ensure the notebook flow remains coherent
    • If the exercise was already converted on main from another group's delivery (late submission on an older notebook version), apply the same co-credit, in a PR of its own. Then close the student's PR with a comment that names the PR carrying the credit.
    • If a notebook accumulates too many examples (>3 consecutive examples on same concept):
      • Keep the 2 most distinct/illustrative ones
      • Remove the others
      • Adjust markdown transitions
  4. Commit changes:
    feat(ece): integrate student exercise <notebook> - <student> (+0.5 bonus)
    
    - Exercise result converted to example
    - New replacement exercise added
    - Reviewed and validated during TP <date>
    
    Co-Authored-By: <Student Name> <student-email-if-available>
    Co-Authored-By: Claude-Code <noreply@anthropic.com>
  5. Push to the main branch of the target student repository (the repo-url argument), after all PRs for the session are processed. That repository's charter governs this push. If the integration lands in jsboige/CoursIA, never push to main: open one PR for the session instead (CLAUDE.md §A, git-workflow.md).

Phase 5 - Cleanup

  1. Close merged PRs with a comment thanking the student and confirming bonus
  2. Update the correction report with final merge status
  3. Summary output to the user with:
    • Number of exercises validated
    • Bonus points attributed per student
    • Any issues requiring manual attention
    • List of notebooks updated with new exercises

Important Notes

  • Timing: Run between classes (e.g., noon-2pm) so afternoon class gets fresh exercises
  • Merge order: Process PRs in submission order (FIFO)
  • Conflict resolution: If two PRs modify the same notebook, merge the first, rebase the second
  • Security: Never execute untrusted code outside the notebook sandbox
  • Backup: Create a local branch backup before merging: backup/pre-merge-<date>
  • No force push: All merges are regular merges or fast-forwards
  • Report confidentiality: Reports in reports/corrections/ are gitignored, never committed

Notebook Types

SeriesKernelExecution Method
Probas.NET C#MCP cell-by-cell
GameTheoryPython (WSL)papermill or notebook_helpers
MLMixed (.NET + Python)Depends on notebook

Spreadsheet Reference

Student inscriptions and evaluations:

  • G:\Mon Drive\MyIA\Formation\ECE\2026\ - CSV/XLSX files
  • Match GitHub usernames to student names for bonus attribution

EPF 2026-2027 (private, outside the repository): one Google Sheets classeur per cohort (IA2-Min1, IA2-Min2, MIS, APP3, MIN52).

  • Where: the keys are those of the SHEETS dict in G:\Mon Drive\MyIA\Formation\EPF\2027\outils-reservation-tp\premier-arrive\gsx.py, which reads the local OAuth profile and never copies it.
  • Tabs: groups (Groupes P1 / Groupes P2, or Groupes), Réservations TP (one row per reserved exercise), and an exercise catalogue.
  • Tools: they are documented in outils-reservation-tp\LISEZMOI.md (catalogue refresh, first-come-first-served lists, verifier_rendu.py).
  • Read-only during class: any write to a student classeur (delivery credit in the teacher table, catalogue refresh) is dry-run on a Drive copy first, never during a session.
  • No personal data: never copy student names or e-mails from these classeurs into the repository, a PR or a public comment. GitHub logins the students used themselves are the only credit.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.