Lovable + Codex workflow
How can you coordinate Lovable and Codex to produce a verifiable prototype without losing control of the code?
- Lovable
- Claude Code
- Codex
3500 € per session, excl. VAT
In short
Over two days, totalling 14 hours excluding breaks, participants build a prototype and organise handovers between Lovable and Codex. They define responsibilities, set boundaries for generated changes, run tests and prepare a pilot. Claude Code is positioned as an alternative for interventions, without multiplying concurrent changes.
Why this training?
Moving from a generated interface to code changes can create discrepancies between intent, behaviour and the retained version. The workflow makes each handover explicit: the context transferred, the files concerned, the expected validation and the person responsible. A convincing screen proves neither the robustness of the rules nor the security of the processing. Participants check generated proposals against reproducible tests and retain the evidence needed to decide whether to proceed or correct them. Running case study: The fictional organisation Aveltre Équipements wants to prototype a repair request tracking system: creation, viewing and status changes. The data is fictional. A prohibited transition and an incomplete entry are used to put the workflow and its controls to the test. Transfer to the workplace: Apply the handover dossier to a small, authorised internal scope, have the changes reviewed by a technical lead and decide whether to launch a pilot based on the tests, risks and rollback conditions.
Objectives of this training
- Define the scope of a feasible prototype and its acceptance criteria.
- Allocate interventions between Lovable, Codex and human review.
- Document a context handover between two tools.
- Test normal user journeys, errors and regressions.
- Build a pilot plan with a launch decision and rollback.
Who is it for and what are the prerequisites?
Roles and tasks concerned
- Developers and technical leads supporting AI-assisted prototypes.
- Technical product managers able to read and test code.
Prior skills
- Be able to read, modify and run a small application.
- Be familiar with the principles of version control, branches and comparing changes.
- Have already used a code generation assistant.
What you will work on
Define the prototype’s scope
Objective: Establish the testable scope. User journeys, exclusions and acceptance criteria.
Assign interventions
Objective: Avoid concurrent changes. Responsibilities, reference version and validations.
Build the first version
Objective: Obtain an inspectable baseline. Bounded instructions and incremental generation with Lovable.
Prepare the handover
Objective: Transfer usable context. Directory structure, business rules, dependencies and known limitations.
Modify without drifting
Objective: Control a targeted correction. Change instructions, comparison and human review.
Establish the tests
Objective: Measure functional conformity. Normal cases, boundary cases and expected results.
Check for secrets
Objective: Reduce avoidable exposure. Separate configuration, minimum permissions and authorised data.
Test a round trip
Objective: Preserve validated corrections. Reference version, conflicts and regression checking.
Prepare the pilot
Objective: Set boundaries for a limited release. Isolated environment, validation, stopping and restoration.
Decide on the evidence
Objective: Justify the prototype’s next steps. Remaining defects and launch conditions.
What you take away
- Version-controlled prototype and execution instructions.
- Lovable–Codex handover dossier and decision log.
- Test report with evidence and defects.
- Pilot plan with responsibilities and rollback.
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 outputs.
- Guided group discussion: what works, what needs correcting and what remains a human decision.
- Preparation: Check access to authorised tools and consult their official documentation for the available transfer and execution methods. Prepare an isolated environment, a training repository and fictional or anonymised data, with no secrets.
Observable criteria: Every retained change has a justification and a human review. ; The three business journeys are tested with expected and observed results. ; Input errors and prohibited transitions are checked. ; No secrets appear in instructions, data or version-controlled files. ; The pilot has explicit launch, stop and restoration conditions..
Frequently asked questions
Will the prototype be in production?
No; the aim is a tested prototype and a pilot plan.
Is Claude Code mandatory?
No; it is positioned as an alternative, depending on the authorisations and access available.
Are transfers automatic?
No automation is assumed; the methods are checked in the official documentation.
Can internal code be used?
Only with authorisation, after removing secrets; the exercises favour the training repository.
Last updated: