TP6 - Generation et debogage de code assistes par IA
Lab Pratique 60 min Intermediaire
Vue d'ensemble du lab
Dans ce lab, vous utiliserez des assistants IA de codage (GitHub Copilot, ChatGPT, Claude ou Cursor) pour realiser des taches de developpement reelles. L'objectif n'est pas d'accepter aveuglement la sortie de l'IA — c'est d'apprendre a formuler des prompts efficaces, reviser de maniere critique et ameliorer de facon iterative.
Objectifs d'apprentissage
a la fin de ce lab, vous serez capable de :
- Rediger des prompts efficaces pour les taches de generation de code
- Reviser et corriger le code genere par l'IA pour la justesse et la securite
- Utiliser l'IA pour deboguer du code defaillant de maniere systematique
- Exploiter l'IA pour le refactoring et l'amelioration des performances
- Generer des tests avec l'IA et valider leur couverture
- Reflechir de maniere critique sur les forces et limites de l'IA
Prerequis
- Python 3.10+ installe
- Acces a au moins un outil IA de codage (ChatGPT, Copilot, Claude ou Cursor)
- Familiarite avec FastAPI, pandas et pytest
- Module 4 et lectures sur l'ingenierie des prompts termines
Outils necessaires
| Outil | Usage | Obligatoire ? |
|---|---|---|
| ChatGPT / Claude | Generation de code conversationnelle | Au moins un |
| VS Code + Copilot ou Cursor | Assistance IA integree | Recommande |
| Python 3.10+ | Execution et test du code | Obligatoire |
| pip | Installation des dependances | Obligatoire |
Configuration
Creez un repertoire de projet et un environnement virtuel :
mkdir tp6-ai-coding && cd tp6-ai-coding
python -m venv venv
# Windows
venv\Scripts\activate
# macOS/Linux
source venv/bin/activate
pip install fastapi uvicorn pandas scikit-learn pytest httpx bandit
Exercice 1 : Pretraitement de donnees genere par l'IA (15 min)
Objectif
Utiliser l'IA pour generer une fonction de pretraitement de donnees, puis la reviser et l'ameliorer.
etape 1 : Redigez votre prompt
Utilisez le prompt suivant avec votre outil IA. Ne le modifiez pas — nous voulons voir ce que l'IA genere a partir d'un prompt standard :
Write a Python function called `preprocess_customer_data` that:
- Accepts a pandas DataFrame with columns:
customer_id (int), name (str), email (str), age (int),
annual_income (float), signup_date (str in YYYY-MM-DD format)
- Performs the following preprocessing:
1. Remove duplicate rows based on customer_id
2. Handle missing values: fill age with median, income with mean,
drop rows where email is missing
3. Validate email format (must contain @ and .)
4. Convert signup_date to datetime
5. Add a column "account_age_days" = days since signup
6. Remove outliers in annual_income (outside 1.5 * IQR)
7. Normalize annual_income to 0-1 range
- Returns the cleaned DataFrame
- Include type hints and a docstring
- Raise ValueError for invalid input (empty DataFrame, missing required columns)
etape 2 : Reviser le code genere
Copiez la sortie de l'IA dans un fichier nomme preprocessing.py. Reviser le code a l'aide de la checklist REVIEW :
| Verification | Question | Vos notes |
|---|---|---|
| R - Lisibilite | Le code est-il clair, bien nomme et documente ? | |
| E - Cas limites | Que se passe-t-il avec un DataFrame vide ? Une colonne entierement NaN ? | |
| V - Vulnerabilites | Des problemes de securite (peu probable ici, mais verifier) ? | |
| I - Integration | S'integrerait-il dans un pipeline de donnees en production ? | |
| E - Efficacite | Des copies inutiles ou des operations redondantes ? | |
| W - Fonctionnement | S'execute-t-il reellement sans erreur ? |
etape 3 : Tester la fonction
Creez un fichier de test test_preprocessing.py et redigez au moins 3 tests manuellement (avant de demander a l'IA) :
import pandas as pd
import pytest
from preprocessing import preprocess_customer_data
def test_basic_preprocessing():
"""Test with clean, valid data."""
df = pd.DataFrame({
"customer_id": [1, 2, 3],
"name": ["Alice", "Bob", "Charlie"],
"email": ["alice@test.com", "bob@test.com", "charlie@test.com"],
"age": [25, 30, 35],
"annual_income": [50000.0, 60000.0, 70000.0],
"signup_date": ["2024-01-15", "2024-03-20", "2024-06-10"],
})
result = preprocess_customer_data(df)
assert len(result) == 3
assert "account_age_days" in result.columns
assert result["annual_income"].min() >= 0
assert result["annual_income"].max() <= 1
def test_empty_dataframe():
"""Test with empty DataFrame — should raise ValueError."""
df = pd.DataFrame()
with pytest.raises(ValueError):
preprocess_customer_data(df)
def test_duplicate_removal():
"""Test that duplicates on customer_id are removed."""
df = pd.DataFrame({
"customer_id": [1, 1, 2],
"name": ["Alice", "Alice", "Bob"],
"email": ["a@test.com", "a@test.com", "b@test.com"],
"age": [25, 25, 30],
"annual_income": [50000.0, 50000.0, 60000.0],
"signup_date": ["2024-01-15", "2024-01-15", "2024-03-20"],
})
result = preprocess_customer_data(df)
assert len(result) == 2
Executez les tests :
pytest test_preprocessing.py -v
etape 4 : Corriger les problemes eventuels
Si les tests echouent, corrigez le code genere par l'IA. Documentez ce que vous avez modifie et pourquoi.
Exercice 2 : Debogage d'un endpoint API defaillant (15 min)
Objectif
Utiliser l'IA pour identifier et corriger des bugs dans un endpoint FastAPI defaillant.
Le code bogue
Creez un fichier nomme buggy_api.py avec le code suivant. Il contient 5 bugs intentionnels — votre tache est d'utiliser l'IA pour tous les trouver et les corriger :
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import json
app = FastAPI()
# Bug 1: Mutable default argument
users_db = []
class User(BaseModel):
name: str
email: str
age: int
class UserResponse(BaseModel):
id: int
name: str
email: str
age: int
# Bug 2: Global mutable counter (not thread-safe)
next_id = 0
@app.post("/users", response_model=UserResponse)
def create_user(user: User):
global next_id
next_id =+ 1 # Bug 3: Operator error (=+ instead of +=)
new_user = {
"id": next_id,
"name": user.name,
"email": user.email,
"age": user.age,
}
users_db.append(new_user)
return new_user
@app.get("/users/{user_id}", response_model=UserResponse)
def get_user(user_id: int):
# Bug 4: Wrong comparison (comparing index, not id)
if user_id < len(users_db):
return users_db[user_id]
raise HTTPException(status_code=404, detail="User not found")
@app.get("/users", response_model=list[UserResponse])
def list_users(min_age: int = None):
if min_age: # Bug 5: Falsy check fails when min_age=0
return [u for u in users_db if u["age"] >= min_age]
return users_db
@app.delete("/users/{user_id}")
def delete_user(user_id: str): # Bug 6 (bonus): wrong type hint
global users_db
users_db = [u for u in users_db if u["id"] != user_id] # Type mismatch
return {"message": "Deleted"}
etape 1 : Tester le prompt de debogage IA
Utilisez ce prompt avec votre outil IA :
I have a FastAPI application with several bugs. Please:
1. Identify ALL bugs in the code
2. Explain what each bug does and why it's a problem
3. Provide the corrected code
4. Suggest additional improvements for production readiness
Here is the code:
[paste the buggy code above]
etape 2 : Verifier l'analyse de l'IA
| Bug # | L'IA l'a trouve ? | Explication correcte ? | Vos notes |
|---|---|---|---|
| Bug 1 (argument mutable par defaut) | Oui / Non | Oui / Non | |
| Bug 2 (securite des threads) | Oui / Non | Oui / Non | |
| Bug 3 (operateur =+) | Oui / Non | Oui / Non | |
| Bug 4 (mauvaise recherche) | Oui / Non | Oui / Non | |
| Bug 5 (verification falsy) | Oui / Non | Oui / Non | |
| Bug 6 (incompatibilite de type) | Oui / Non | Oui / Non |
etape 3 : Appliquer les corrections
Creez fixed_api.py avec le code corrige. Executez-le et testez manuellement :
uvicorn fixed_api:app --reload
# Test with curl or httpx
curl -X POST http://localhost:8000/users \
-H "Content-Type: application/json" \
-d '{"name": "Alice", "email": "alice@test.com", "age": 25}'
Exercice 3 : Refactoring assiste par l'IA (10 min)
Objectif
Utiliser l'IA pour refactoriser une fonction mal ecrite afin d'ameliorer la lisibilite et les performances.
Le code desordonne
Creez un fichier nomme messy_code.py :
def process(d):
r = []
for i in range(len(d)):
if d[i]['status'] == 'active' and d[i]['age'] >= 18:
if d[i]['email'] != None and d[i]['email'] != '':
x = {}
x['name'] = d[i]['first_name'] + ' ' + d[i]['last_name']
x['email'] = d[i]['email'].lower().strip()
x['category'] = ''
if d[i]['age'] >= 18 and d[i]['age'] < 25:
x['category'] = 'young_adult'
elif d[i]['age'] >= 25 and d[i]['age'] < 35:
x['category'] = 'adult'
elif d[i]['age'] >= 35 and d[i]['age'] < 50:
x['category'] = 'middle_aged'
elif d[i]['age'] >= 50:
x['category'] = 'senior'
x['score'] = d[i]['purchases'] * 10 + d[i]['reviews'] * 5 + d[i]['referrals'] * 20
if x['score'] > 100:
x['tier'] = 'gold'
elif x['score'] > 50:
x['tier'] = 'silver'
else:
x['tier'] = 'bronze'
r.append(x)
return r
Votre prompt
Redigez un prompt demandant a l'IA de refactoriser ce code. Votre prompt doit demander :
- Des noms de variables et de fonctions significatifs
- Des annotations de type et une docstring
- L'utilisation de modeles Pydantic pour l'entree et la sortie
- L'extraction de la logique de categorisation et de scoring dans des fonctions auxiliaires
- L'utilisation de list comprehension ou de
filter()lorsque c'est approprie
evaluation
Comparez la version refactorisee par l'IA a cette checklist :
- La fonction a un nom descriptif
- Les parametres ont des annotations de type
- Le type de retour est specifie
- La docstring explique l'objectif, les arguments et les retours
- Les noms de variables sont descriptifs
- La logique est decoupee en fonctions plus petites
- Pas de conditions repetees
- Utilise Pydantic ou dataclasses pour la structure
Exercice 4 : Tests unitaires generes par l'IA (10 min)
Objectif
Utiliser l'IA pour generer une suite de tests complete, puis evaluer sa qualite.
La fonction a tester
Utilisez votre code refactorise de l'exercice 3 (ou la fonction process d'origine si vous preferez).
Votre prompt
Write a comprehensive pytest test suite for the following function.
Include:
1. Happy path tests (normal valid input)
2. Edge cases (empty list, single item, all filtered out)
3. Boundary tests (age exactly 18, 25, 35, 50)
4. Score boundary tests (score exactly 50, 100)
5. Invalid input handling (missing keys, wrong types)
6. Use @pytest.mark.parametrize for boundary tests
[paste your function here]
evaluer les tests
| Critere | Tests de l'IA | Votre evaluation |
|---|---|---|
| Couverture | Quel % des chemins de code sont testes ? | |
| Cas limites | Les entrees vides et les bornes sont-elles couvertes ? | |
| Assertions | Les assertions sont-elles specifiques et pertinentes ? | |
| Independance | Les tests s'executent-ils independamment (pas d'etat partage) ? | |
| Nommage | Les noms des tests decrivent-ils le scenario ? | |
| Redondance | Y a-t-il des tests dupliques ou qui se chevauchent ? |
Executez les tests :
pytest test_refactored.py -v --tb=short
Exercice 5 : Analyse de securite (5 min)
Objectif
Executer une analyse de securite sur tout le code genere par l'IA de ce lab.
Executer Bandit
# Scan all Python files in the project
bandit -r . -ll
# If Bandit finds issues, document them:
bandit -r . -f json -o security_report.json
Documenter les resultats
| Fichier | Probleme | Severite | Corrige ? |
|---|---|---|---|
Exercice 6 : Rapport de reflexion (5 min)
Objectif
Rediger une courte reflexion sur votre experience avec les outils IA de codage. Cela developpe votre pensee critique sur l'IA comme outil de developpement.
Modele de reflexion
Copiez ce modele et completez-le :
# TP6 Reflection Report
## Student: [Your Name]
## Date: [Date]
## 1. AI Tool(s) Used
- Tool: [e.g., ChatGPT, Copilot, Claude, Cursor]
- Model: [e.g., GPT-4o, Claude 3.5 Sonnet]
## 2. What AI Did Well
- [List 3 specific things the AI handled effectively]
- Example:
- Example:
- Example:
## 3. What AI Got Wrong
- [List 3 specific errors or issues you found]
- Example:
- Example:
- Example:
## 4. Prompt Engineering Insights
- Best prompt strategy I used: [zero-shot / few-shot / CoT]
- Most effective prompt technique: [describe]
- A prompt that didn't work well: [describe and explain why]
## 5. Time Analysis
| Task | Estimated Without AI | Actual With AI | Time Saved |
|------|---------------------|----------------|------------|
| Data preprocessing function | | | |
| Debugging API | | | |
| Refactoring | | | |
| Writing tests | | | |
## 6. Security Findings
- Number of vulnerabilities found by Bandit: [N]
- Most critical issue: [describe]
- Were any vulnerabilities in AI-generated code? [Yes/No — describe]
## 7. Key Takeaways
1. [Most important lesson learned]
2. [How will you use AI tools differently going forward?]
3. [What should you always do manually, even with AI?]
Checklist de remise
Avant de remettre, verifiez que vous avez :
-
preprocessing.py— Code genere par l'IA + vos corrections (Exercice 1) -
test_preprocessing.py— Vos tests manuels (Exercice 1) -
buggy_api.py— Code bogue d'origine (Exercice 2) -
fixed_api.py— Code corrige avec tous les bugs resolus (Exercice 2) - Tableau d'analyse des bugs documentant ce que l'IA a trouve vs. manque (Exercice 2)
-
refactored_code.py— Version refactorisee du code desordonne (Exercice 3) -
test_refactored.py— Suite de tests generee par l'IA (Exercice 4) -
security_report.json— Resultats du scan Bandit (Exercice 5) -
reflection.md— Votre rapport de reflexion (Exercice 6)
Grille d'evaluation
| Critere | Points | Description |
|---|---|---|
| Generation de code | 20 | Qualite des prompts et du code genere |
| Revue de code | 20 | Identification et correction approfondies des problemes |
| Debogage | 20 | Tous les bugs trouves et correctement corriges |
| Refactoring | 15 | Code refactorise propre et bien structure |
| Tests | 15 | Tests complets avec bonne couverture |
| Reflexion | 10 | Analyse pertinente des forces/faiblesses de l'IA |
| Total | 100 |