Git history under control

How can you keep changes readable and undo an error without losing validated work?

  • Lovable
  • Claude Code
  • Codex

1250 € per session, excl. VAT

In short

In a half-day session of 3 hours participants practise the Git operations needed to track a small AI-assisted project: inspecting differences, creating commits, isolating a change and correcting an error. They leave with a verified local repository, a readable history and a reusable procedure.

Why this training?

Changes generated from instructions can affect several files and mix corrections, presentation and behaviour. Without a structured history, identifying the source of a regression becomes difficult, and successive copies of folders do not allow changes to be compared properly. Git makes decisions traceable, provided that differences are reviewed and work is broken down. The training prioritises operations that can be explained: knowing what will be recorded, why a branch exists and how to undo a commit while retaining a record. Running case study: The fictional organisation ‘Avelune Prêtothèque’ is developing a small equipment-booking interface. An AI-assisted change improves the labels but introduces a validation regression. Participants must separate these changes, integrate a concurrent correction and undo the regression without deleting the useful history. Transfer to the workplace: On an authorised project, repeat the status, diff, selection, test and commit routine. Examine the next five commits using the checklist: a single intent, an explicit message, recorded tests and no secrets. Then adjust the size of the changes.

Objectives of this training

  • Initialise a local repository and distinguish between modified, staged and committed files.
  • Inspect differences before selecting the files for a commit.
  • Create a branch and merge a controlled change.
  • Resolve a simple conflict, then verify the resulting behaviour.
  • Undo a commit with revert and document the checks performed.

Who is it for and what are the prerequisites?

Roles and tasks concerned

  • Creators of small projects using Lovable, Claude Code or Codex to generate or modify code.
  • Staff required to take over and correct a shared project, without regular Git practice.

Prior skills

  • Be able to open a project, modify a file and run a command in a terminal.
  • Have already used a coding assistant and recognise the main files in your project.

What you will work on

  1. Establish the foundations and protect files

    Objective: Build an initial, checked baseline. Repository, working directory, index and commit; init, status, add, commit; exclusions through .gitignore and limitations for files already tracked.

  2. Review and break down changes

    Objective: Record only changes that are understood and tested. diff, diff --staged and log; commit intent; human review of code generated or modified from instructions.

  3. Isolate and then bring work together

    Objective: Merge a branch while handling a simple conflict. switch, branches and merge; origins of conflicts; reading concurrent versions and validating after resolution.

  4. Undo without erasing and check

    Objective: Restore a working state with an explicit record. Searching log, undoing with revert, distinction from destructive commands; local versus remote repository and principles of authorised synchronisation.

What you take away

  • Local repository with a history of coherent commits and a merged branch.
  • Adapted .gitignore file and an example configuration without secrets.
  • Test log before and after merging and undoing.
  • Git reference sheet and completed checklist.

Method and assessment

  • Short explanations followed by immediate practice on the running case study.
  • Individual work followed by work in pairs, with peer review of the outputs.
  • Guided group discussion: what works, what needs correcting and what remains a human decision.
  • Preparation: Install Git, check your commit identity and have an authorised terminal and editor available. Prepare the supplied fictional project with its tests and, optionally, authorised organisational access to Lovable, Claude Code or Codex; no confidential data is required.

Observable criteria: Each commit examined corresponds to an identifiable intent and has an explicit message. ; The sensitive files specified in the exercise remain untracked; no secrets appear in the commits. ; The merge leaves no conflict markers and the planned tests pass. ; The revert undoes the targeted regression without removing the independent improvement. ; The participant explains status, diff and log using their repository..

Frequently asked questions

Is a coding assistant essential?

No. The supplied changes allow you to practise Git without an assistant.

Are all three tools used?

No. One authorised tool is sufficient; consult its official documentation for the exact capabilities and terms.

Can real data be used?

The exercises use only fictional or anonymised cases, without secrets.

Will the project be put into production?

No. The deliverable is a checked local repository; no actual deployment is planned.

Last updated: