Cours Vibe coding avec Claude Code · Module 7: Clone de LinkedIn

Livret de marin : profil professionnel et premier skill maison

13 min de lecture
Dans cette leçon12

Ohé ! Dans les tavernes du port, les capitaines cherchent des navigateurs et les navigateurs de bons navires, mais personne ne sait qui sait faire quoi. Dans ce module, tu construis Crew Connections, un réseau professionnel de pirates sur le modèle de LinkedIn. Dans Kraken's Call, le clone de Twitter, comptaient les messages légers et les likes ; ici comptent les postes, l'ancienneté et les compétences confirmées par l'équipage. Le profil fait office de livret de marin : il montre où tu as navigué et ce que tu sais faire.

Au programme

  • demander à Claude Code un profil avec expérience et validations de compétences ;
  • lire un formulaire avec Server Action, validation côté serveur et erreurs sous les champs ;
  • vérifier que les règles sont gardées par le serveur et pas seulement par le bouton ;
  • enregistrer une procédure répétable comme skill Claude Code et lire son fichier.

Nouveau port : le projet crew-connections

Le réseau professionnel est une application à part : tu la crées avec la commande de la leçon 1_2 en changeant seulement le nom. Avant de cliquer sur Yes, compare la commande avec celle-ci :

npx create-next-app@latest crew-connections --ts --eslint --tailwind --app --no-src-dir --no-cache-components --agents-md --no-agent-feedback --use-npm

Ensuite, la boucle habituelle : une session dans le dossier crew-connections, un CLAUDE.md qui importe @AGENTS.md, Vitest avec le même correctif @types/node que dans la leçon 4_1, et un premier commit.

Problème : trois formulaires qui se ressemblent

Un pirate veut corriger son titre professionnel, un capitaine veut ajouter une offre d'emploi, un candidat veut envoyer sa candidature. Ce sont trois formulaires avec le même risque : le navigateur ne vérifie que ce que tu lui demandes, et n'importe qui peut envoyer ce qu'il veut au serveur. C'est pourquoi le serveur garde les règles. Tu construis le premier formulaire proprement, puis tu notes la recette pour que Claude la rejoue en une seule commande.

Demande pour Claude Code :

/plan Construis dans Crew Connections un profil professionnel. Page
/in/[handle] : en-tête (nom, headline, port, nombre de contacts),
expérience avec une ancienneté calculée à partir des dates (pas de
endDate = le poste continue) et compétences avec validations. On ne
peut valider que la compétence d'un autre, et une seule fois ; c'est
le serveur qui le garantit. Page /profile/edit avec un formulaire :
enregistrement par Server Action, validation côté serveur d'après le
guide Forms de node_modules/next/dist/docs, erreurs sous les champs,
valeurs saisies conservées après une erreur. Pas encore de connexion :
le pirate connecté vient d'une seule fonction dans lib/session.ts.
Données dans data/*.json. Formatage des dates dans lib/format.ts,
tests d'abord. À la fin : tests, lint, types, build.

Dans le plan, tu cherches trois choses : la validation dans un fichier avec "use server", le pirate pris dans lib/session.ts et non dans un champ du formulaire, et les tests écrits avant le code de formatage. Claude a proposé la bibliothèque Zod, que le guide Forms recommande pour la validation côté serveur. C'est un seul paquet, donc d'accord.

Ce que Claude a écrit : le profil en types

Ouvre types/profile.ts dans Cursor. Le type Profile contient handle (le nom court dans l'adresse, comme redbeard), le nom, le headline, c'est-à-dire le titre professionnel du genre "Capitaine et navigateur sur la Black Pearl", le port, le texte "À propos", le nombre de contacts et les listes d'expérience et de compétences. Pas de champs tweets ou likes : c'est un autre monde. Deux types plus petits en dessous :

export interface Experience {
  id: string;
  title: string;
  company: string;
  startDate: string; // "2023-03" : année et mois en texte ISO
  endDate?: string; // absent = le poste continue
  description?: string;
}

export interface Skill {
  id: string;
  name: string;
  endorsedBy: string[]; // handles des personnes qui ont validé la compétence
}

Sans endDate, le poste est toujours en cours. Une validation (en anglais endorsement) est un clic par lequel tu te portes garant que quelqu'un maîtrise vraiment la navigation, donc endorsedBy garde la liste de ceux qui se sont déjà portés garants. La recommandation est autre chose : une référence écrite sur toute une collaboration, que tu ajouteras plus tard.

L'ancienneté calculée à partir des dates

Ouvre lib/format.ts. Claude a d'abord écrit les tests, puis la fonction :

export function formatDuration(start: string, end?: string, today = new Date()): string {
  const until = end ?? `${today.getFullYear()}-${String(today.getMonth() + 1).padStart(2, "0")}`;
  const months = monthsBetween(start, until);
  if (months < 1) return "moins d'un mois";
  const years = Math.floor(months / 12);
  const rest = months % 12;
  const parts: string[] = [];
  if (years > 0) parts.push(formatYears(years));
  if (rest > 0) parts.push(`${rest} mois`);
  return parts.join(" ");
}

monthsBetween compte les mois entre deux dates, puis la fonction les découpe en années et en reste : de mars 2023 à août 2025, cela fait 29 mois, donc "2 ans 5 mois". Sans date de fin, elle compte jusqu'à today, et ce paramètre permet aux tests de fournir une date fixe. formatYears, dans le même fichier, choisit la forme avec l'outil intégré Intl.PluralRules("fr-FR") : 1 an, 2 ans (en français, 0 et 1 sont au singulier). Dans ExperienceSection, la ligne de dates ressemble à ceci : formatMonth(job.startDate) - en cours · formatDuration(...), par exemple "mars 2023 - en cours".

Validations : c'est le serveur qui décide

Une Server Action est une fonction avec la directive "use server" qui s'exécute sur le serveur, et le navigateur l'appelle en envoyant un formulaire. Ouvre components/profile/SkillsSection.tsx (classes omises) :

{!isOwn && (
  <form action={endorseSkill.bind(null, profile.handle, skill.id)}>
    <button disabled={endorsed}>{endorsed ? "Validée" : "+ Valider"}</button>
  </form>
)}

bind colle à l'action le handle du profil et l'identifiant de la compétence ; c'est ainsi que la documentation transmet des arguments supplémentaires. Sur ton propre profil, il n'y a pas de boutons, et un bouton désactivé n'est qu'une indication. La documentation des Server Actions avertit qu'une requête peut être envoyée sans passer par l'interface, donc endorseSkill dans app/in/[handle]/actions.ts revérifie tout : elle interroge getCurrentUser(), refuse ton propre profil et une deuxième validation, ajoute le handle à endorsedBy, enregistre et appelle revalidatePath pour que la page affiche le nouveau nombre.

Formulaire : les règles dans un schéma

Ouvre lib/validation/profile.ts. Un schéma Zod est la description des données valides :

export const profileSchema = z.object({
  name: z.string().trim().min(2, "Indique ton nom (2 caractères minimum).").max(60, "60 caractères maximum."),
  headline: z.string().trim().min(5, "Décris-toi en quelques mots (5 caractères minimum).").max(120, "120 caractères maximum."),
  location: z.string().trim().max(60, "60 caractères maximum."),
  about: z.string().trim().max(1000, "1000 caractères maximum."),
});

trim() retire les espaces avant que min n'agisse, donc un nom fait uniquement d'espaces ne passe pas. Le schéma n'enregistre rien et ne lève pas d'exception : son safeParse renvoie soit les données corrigées, soit une liste d'erreurs.

Formulaire : l'action sur le serveur

Ouvre app/profile/edit/actions.ts :

export async function updateProfile(
  _prevState: FormState<ProfileInput>,
  formData: FormData,
): Promise<FormState<ProfileInput>> {
  const user = await getCurrentUser();
  const values = {
    name: String(formData.get("name") ?? ""),
    headline: String(formData.get("headline") ?? ""),
    location: String(formData.get("location") ?? ""),
    about: String(formData.get("about") ?? ""),
  };

  const result = profileSchema.safeParse(values);
  if (!result.success) {
    return { values, errors: z.flattenError(result.error).fieldErrors };
  }

  const profile = await getProfile(user.handle);
  if (!profile) {
    return { values, errors: {}, message: "Profil introuvable." };
  }

  await saveProfile({ ...profile, ...result.data });
  revalidatePath(`/in/${user.handle}`);
  redirect(`/in/${user.handle}`);
}

L'action ne lit dans FormData que les quatre champs attendus, et le propriétaire du profil vient de la session, pas du formulaire. En cas d'erreur, elle renvoie les valeurs saisies et des erreurs du genre { name: ["Indique ton nom (2 caractères minimum)."] }, sans rien enregistrer. En cas de succès, saveProfile écrit le profil via lib/store.ts dans le fichier data/profiles.json (Claude a ajouté le dossier data au .gitignore), revalidatePath rafraîchit la page du profil et redirect y renvoie ; le code après redirect ne s'exécute plus.

Formulaire : les erreurs sous les champs

Ouvre components/profile/ProfileForm.tsx. C'est un Client Component avec le hook React useActionState, qui garde le dernier résultat de l'action (classes du bouton omises) :

const [state, formAction, pending] = useActionState(updateProfile, { values: initial, errors: {} });

return (
  <form action={formAction} className="space-y-4">
    <Field label="Nom et prénom" name="name" defaultValue={state.values.name} errors={state.errors.name} maxLength={60} />
    {/* headline, port et "À propos" de la même façon */}
    <button type="submit" disabled={pending}>{pending ? "Enregistrement..." : "Enregistrer le profil"}</button>
  </form>
);

state est le dernier résultat, formAction va dans le formulaire et pending bloque le bouton pendant l'envoi. Field dessine l'étiquette, le champ et l'erreur reliée au champ par aria-describedby, donc un lecteur d'écran la lit avec le champ.

La revue du capitaine

  1. Des espaces à la place du nom. Lance npm run dev, tape trois espaces dans le nom et change le titre. Le navigateur laisse passer, le serveur répond "Indique ton nom (2 caractères minimum).", et le nouveau titre reste dans le champ. L'erreur typique d'un agent est defaultValue={initial.name} : après l'action, React remet le formulaire à ses valeurs par défaut, donc chez nous le nouveau titre avait disparu après l'erreur et sous le champ avec l'ancien nom s'affichait un message disant que le nom manquait.
  2. L'exemple de la documentation dans une autre version. Le premier schéma avait invalid_type_error et .flatten(), recopiés du guide Forms, et npx tsc --noEmit a signalé que invalid_type_error n'existe pas. npm a installé Zod 4 (état en novembre 2026 : 4.6.7), où cette option n'existe plus et où .flatten() est obsolète. Le guide et le paquet peuvent parler de versions différentes ; le compilateur tranche.
  3. La page d'édition après le build. Lance npm run build et npm start, enregistre un nouveau titre et reviens sur /profile/edit. Chez nous, le formulaire affichait l'ancien, parce que le build avait marqué la page d'un ○, c'est-à-dire statique, et l'avait rendue une seule fois. Correction : getCurrentUser() appelle await connection() depuis next/server, comme une vraie session qui lit la requête. Après un nouveau build, la page porte le signe ƒ.

Skill : la recette écrite sur le parchemin

Un skill est un fichier avec une consigne que Claude Code ne charge dans la conversation que lorsqu'elle est utile : quand tu tapes sa commande, ou quand Claude juge qu'elle convient à la tâche. Un skill de projet vit dans .claude/skills/<nom>/SKILL.md et devient la commande /nom. CLAUDE.md est la loi du bord, lue à chaque session ; le skill est la recette qu'on sort du coffre quand on en a besoin.

Demande pour Claude Code :

Note comment nous avons construit le formulaire de profil (validation,
enregistrement côté serveur, messages d'erreur) sous forme de skill
/nouveau-formulaire dans .claude/skills/. Moi seul peux le lancer.
Je donnerai le nom du formulaire en argument. Le skill doit d'abord
me demander les champs, puis lancer les tests, le lint, les types
et le build.

Ouvre .claude/skills/nouveau-formulaire/SKILL.md. En haut se trouve le frontmatter, c'est-à-dire les réglages entre les lignes --- :

---
name: nouveau-formulaire
description: Construit un formulaire Crew Connections d'après le modèle du formulaire de profil (Server Action, validation Zod côté serveur, erreurs sous les champs).
argument-hint: "[ce que le formulaire enregistre, par ex. offre d'emploi]"
disable-model-invocation: true
---

name donne la commande /nouveau-formulaire, et argument-hint l'indication affichée pendant la saisie. disable-model-invocation: true réalise ton "seulement moi" : Claude ne lancera pas le skill tout seul et, selon la documentation, même sa description ne reste pas dans le contexte tant que tu n'as pas tapé la commande. Dessous vient le contenu :

# Nouveau formulaire : $ARGUMENTS

Construis un formulaire qui enregistre : $ARGUMENTS. Le modèle est le formulaire de profil :
- lib/validation/profile.ts et lib/validation/profile.test.ts (schéma et tests),
- app/profile/edit/actions.ts (Server Action),
- components/profile/ProfileForm.tsx et components/ui/Field.tsx (formulaire).

## Avant d'écrire du code

1. Liste les champs : nom, type, obligatoire ou non, limites, valeurs autorisées.
2. Écris qui peut envoyer le formulaire et sur quoi il porte (quel profil, quelle offre).
3. Demande-moi si la liste est correcte. Ne commence pas sans réponse.

## Étapes

1. Tests du schéma dans lib/validation/<nom>.test.ts : données valides, champ obligatoire fait d'espaces, texte trop long, valeur hors liste. D'abord les tests, ensuite le schéma.
2. Schéma Zod 4 dans lib/validation/<nom>.ts : messages en français, .trim() sur les champs texte, listes fermées en tableau `as const` avec z.enum. Pas d'invalid_type_error ni de .flatten() (c'est l'API de Zod 3).
3. Server Action dans actions.ts à côté de la page, avec "use server" en haut du fichier :
   - le pirate connecté seulement via getCurrentUser() de lib/session.ts, jamais depuis les champs du formulaire ;
   - ne lis dans FormData que les champs attendus ;
   - en cas d'erreur, renvoie { values, errors } avec z.flattenError(...).fieldErrors et n'enregistre rien ;
   - l'auteur, le statut et les dates sont fixés par le serveur ;
   - enregistrement via lib/store.ts, puis revalidatePath et redirect.
4. Formulaire en Client Component avec useActionState : chaque champ via Field, defaultValue pris dans state.values (React vide les champs après l'action), bouton désactivé pendant pending.

## Vérification

- npm run test -- --run, npm run lint, npx tsc --noEmit, npm run build.
- Dans le résultat du build, la page du formulaire est marquée ƒ et non ○.
- Montre-moi les résultats et la liste des fichiers modifiés. N'ajoute pas de bibliothèque sans demander.

$ARGUMENTS est remplacé par Claude Code par ce que tu tapes après la commande. Remarque que les trois découvertes de la revue sont devenues des règles du skill : les valeurs de state.values, Zod 4 et le signe ƒ. Le dossier .claude/skills n'existait pas quand tu as démarré la session, et la documentation dit qu'un tel dossier doit être chargé une fois avec la commande /reload-skills. Ensuite, /skills affiche le skill dans la liste.

Étape suivante

Quand la revue est passée, demande un commit, par exemple "Profil professionnel, formulaire d'édition et skill nouveau-formulaire". Le skill part dans le commit avec le code, donc toute personne qui clone le projet le reçoit. Puis un petit pas avec un test :

Extrais de endorseSkill une fonction pure canEndorse dans lib/endorse.ts.
D'abord les tests : sa propre compétence, deuxième validation, compétence
inconnue. Montre l'échec, puis le code. Ne modifie pas les tests.

Dans l'éditeur ci-dessous t'attend un profil en miniature : ancienneté calculée à partir des dates, validations et formulaire dont le "serveur" vérifie les mêmes règles que le schéma. Passe sur ton profil, tape uniquement des espaces dans le nom et regarde ce qui reste dans les champs.

Souviens-toi : le livret de marin est signé par le capitaine du port, pas par le marin lui-même, et de la même façon les règles d'un formulaire sont signées par le serveur.

Code de cette leçon : App.jsx
// Livret de marin en miniature : ancienneté calculée à partir des dates, validations et formulaire avec un « serveur ».
// Dans le projet, les règles sont vérifiées par une Server Action avec un schéma Zod ; ici, le même jeu de règles
// est vérifié par la fonction serverUpdateProfile, qui répond avec un délai comme un vrai serveur.
import { useState } from 'react';

const TODAY = '2026-11';
const VIEWER = 'redbeard';
const yearWords = { one: 'an', many: 'ans', other: 'ans' };
const plural = new Intl.PluralRules('fr-FR');
const monthYear = new Intl.DateTimeFormat('fr-FR', { month: 'short', year: 'numeric' });

function monthsBetween(start, end) {
  const [sy, sm] = start.split('-').map(Number);
  const [ey, em] = end.split('-').map(Number);
  return (ey - sy) * 12 + (em - sm);
}

function formatDuration(start, end) {
  const months = monthsBetween(start, end ?? TODAY);
  if (months < 1) return "moins d'un mois";
  const years = Math.floor(months / 12);
  const rest = months % 12;
  const parts = [];
  if (years > 0) parts.push(years + ' ' + yearWords[plural.select(years)]);
  if (rest > 0) parts.push(rest + ' mois');
  return parts.join(' ');
}

function formatMonth(value) {
  const [year, month] = value.split('-').map(Number);
  return monthYear.format(new Date(year, month - 1, 1));
}

const initialProfiles = {
  redbeard: {
    handle: 'redbeard', name: 'Capitaine Barbe-Rousse', headline: 'Capitaine et navigateur sur la Black Pearl',
    experience: [
      { id: 'e1', title: 'Capitaine', company: 'Black Pearl', startDate: '2023-03' },
      { id: 'e2', title: 'Premier officier', company: 'Hollandais Volant', startDate: '2018-06', endDate: '2023-02' },
    ],
    skills: [
      { id: 's1', name: 'Navigation', endorsedBy: ['anne', 'jack'] },
      { id: 's2', name: 'Cartographie', endorsedBy: ['anne'] },
    ],
  },
  anne: {
    handle: 'anne', name: 'Anne Bonny', headline: 'Première officière, spécialiste de l’abordage',
    experience: [{ id: 'e3', title: 'Première officière', company: 'Revanche de la Reine Anne', startDate: '2024-01' }],
    skills: [
      { id: 's4', name: 'Abordage', endorsedBy: ['jack'] },
      { id: 's5', name: 'Escrime', endorsedBy: [] },
    ],
  },
};

// « Serveur » : les mêmes règles que le schéma profileSchema du projet.
function validateProfile(values) {
  const errors = {};
  const name = values.name.trim();
  const headline = values.headline.trim();
  if (name.length < 2) errors.name = 'Indique ton nom (2 caractères minimum).';
  else if (name.length > 60) errors.name = '60 caractères maximum.';
  if (headline.length < 5) errors.headline = 'Décris-toi en quelques mots (5 caractères minimum).';
  else if (headline.length > 120) errors.headline = '120 caractères maximum.';
  return { errors, data: { name, headline } };
}

function serverUpdateProfile(values) {
  return new Promise((resolve) => setTimeout(() => resolve(validateProfile(values)), 600));
}

// « Serveur » des validations : il refuse sa propre compétence et une deuxième validation.
function canEndorse(viewer, profile, skill) {
  return viewer !== profile.handle && !skill.endorsedBy.includes(viewer);
}

export default function App() {
  const [profiles, setProfiles] = useState(initialProfiles);
  const [shown, setShown] = useState('anne');
  const [values, setValues] = useState({ name: initialProfiles.redbeard.name, headline: initialProfiles.redbeard.headline });
  const [errors, setErrors] = useState({});
  const [pending, setPending] = useState(false);
  const profile = profiles[shown];
  const isOwn = shown === VIEWER;

  const endorse = (skill) => {
    if (!canEndorse(VIEWER, profile, skill)) return;
    setProfiles((prev) => ({
      ...prev,
      [shown]: {
        ...profile,
        skills: profile.skills.map((s) => (s.id === skill.id ? { ...s, endorsedBy: [...s.endorsedBy, VIEWER] } : s)),
      },
    }));
  };

  const handleSubmit = async (event) => {
    event.preventDefault();
    setPending(true);
    const result = await serverUpdateProfile(values);
    setPending(false);
    setErrors(result.errors);
    if (Object.keys(result.errors).length === 0) {
      setProfiles((prev) => ({ ...prev, redbeard: { ...prev.redbeard, ...result.data } }));
      setValues(result.data);
    }
  };

  return (
    <div className="min-h-screen bg-gray-100 p-4 text-gray-900">
      <div className="mx-auto max-w-2xl space-y-4">
        <div className="flex gap-2 text-sm">
          <span className="py-1">Tu regardes :</span>
          {Object.values(profiles).map((p) => (
            <button
              key={p.handle}
              type="button"
              onClick={() => setShown(p.handle)}
              className={shown === p.handle ? 'rounded-full bg-blue-600 px-3 py-1 text-white' : 'rounded-full border border-gray-300 bg-white px-3 py-1'}
            >
              {p.handle === VIEWER ? 'Ton profil' : p.name}
            </button>
          ))}
        </div>

        <section className="rounded-lg border border-gray-200 bg-white p-5">
          <h1 className="text-2xl font-bold">{profile.name}</h1>
          <p className="text-gray-700">{profile.headline}</p>
          <h2 className="mt-4 font-bold">Expérience</h2>
          <ul className="divide-y divide-gray-200">
            {profile.experience.map((job) => (
              <li key={job.id} className="py-2">
                <p className="font-semibold">{job.title}, {job.company}</p>
                <p className="text-sm text-gray-500">
                  {formatMonth(job.startDate)} - {job.endDate ? formatMonth(job.endDate) : 'en cours'} · {formatDuration(job.startDate, job.endDate)}
                </p>
              </li>
            ))}
          </ul>
          <h2 className="mt-4 font-bold">Compétences</h2>
          <ul className="divide-y divide-gray-200">
            {profile.skills.map((skill) => {
              const endorsed = skill.endorsedBy.includes(VIEWER);
              return (
                <li key={skill.id} className="flex items-center justify-between py-2">
                  <span>{skill.name} <span className="text-sm text-gray-500">(validations : {skill.endorsedBy.length})</span></span>
                  {!isOwn && (
                    <button
                      type="button"
                      disabled={endorsed}
                      onClick={() => endorse(skill)}
                      className="rounded-full border-2 border-blue-600 px-3 py-0.5 text-sm font-semibold text-blue-600 disabled:border-gray-200 disabled:text-gray-500"
                    >
                      {endorsed ? 'Validée' : '+ Valider'}
                    </button>
                  )}
                </li>
              );
            })}
          </ul>
        </section>

        {isOwn && (
          <form onSubmit={handleSubmit} noValidate className="space-y-3 rounded-lg border border-gray-200 bg-white p-5">
            <h2 className="font-bold">Modifier le profil</h2>
            {[['name', 'Nom et prénom'], ['headline', 'Titre professionnel']].map(([field, label]) => (
              <div key={field}>
                <label htmlFor={field} className="block font-semibold">{label}</label>
                <input
                  id={field}
                  value={values[field]}
                  onChange={(e) => setValues({ ...values, [field]: e.target.value })}
                  aria-invalid={errors[field] ? true : undefined}
                  aria-describedby={errors[field] ? field + '-error' : undefined}
                  className="w-full rounded-lg border border-gray-300 px-3 py-2"
                />
                {errors[field] && <p id={field + '-error'} className="text-sm text-red-600">{errors[field]}</p>}
              </div>
            ))}
            <button type="submit" disabled={pending} className="rounded-full bg-blue-600 px-5 py-2 font-semibold text-white disabled:bg-gray-300">
              {pending ? 'Enregistrement...' : 'Enregistrer le profil'}
            </button>
          </form>
        )}
      </div>
    </div>
  );
}

Tu as repéré une erreur dans cette leçon ?

Teste tes connaissances

Réponds aux questions de cette leçon. Choisis une réponse pour voir tout de suite si elle est correcte.

  1. 1. Quels champs n'appartiennent PAS au type Profile dans Crew Connections ?

  2. 2. Que renvoie formatDuration("2023-03", "2025-08") ?

Voici 2 des 6 questions de cette leçon. Réponds aux autres dans le jeu.

Tâches pratiques dans le jeu

  • Éditeur de code

    En-tête de profil professionnel

  • Tri vertical

    Ordonne les éléments de l'en-tête du profil (ProfileHeader) de haut en bas :

  • Clique dans l'ordre

    Ordonne la lecture des erreurs par champ à partir du résultat de validation : z.flattenError(result.error).fieldErrors

  • Clique dans l'ordre

    Ordonne la lecture du nombre de contacts depuis le profil : profile.connections

  • Clique dans l'ordre

    Ordonne l'attache de l'action au formulaire de validation : endorseSkill.bind(null, profile.handle, skill.id)

  • Tri vertical

    Ordonne ce qui se passe après un clic sur + Valider sur le profil de quelqu'un d'autre :

  • Éditeur de code

    Composant section Compétences

  • Tri horizontal

    Ordonne sur une seule ligne la ligne de dates de ExperienceSection : formatMonth(job.startDate) - en cours · formatDuration(...)

  • Tri vertical

    Ordonne les étapes de la Server Action updateProfile :

  1. QuestionQuiz : Champs du type Profile
  2. QuestionQuiz : Résultat de formatDuration
  3. Exercice de codePratique : En-tête du profil
  4. QuestionQuiz : Le champ headline
  5. QuestionQuiz : Le poste qui continue
  6. Remets dans l'ordreTri : L'en-tête du profil de haut en bas
  7. Clique dans l'ordreTri : Lecture des erreurs de validation
  8. Clique dans l'ordreTri : Lire profile.connections
  9. Clique dans l'ordreTri : Action avec des arguments supplémentaires
  10. QuestionQuiz : Validations de compétences
  11. QuestionQuiz : recommandations et validations de compétences
  12. Remets dans l'ordreTri : Validation de compétence sur le serveur
  13. Exercice de codePratique : Compétences avec endorsements
  14. Remets dans l'ordreTri : La ligne de dates d'un poste
  15. Remets dans l'ordreTri : Étapes de l'action updateProfile

Articles utiles