Le plan d'action du AI
Toutes les actions concrètes distillées des leçons du parcours AI, dédoublonnées et organisées par phase. Chaque action renvoie à la leçon qui la fonde.
Cochez au fur et à mesure — sauvegardé dans ce navigateur.
AI & LLM foundations
What AI, machine learning, and large language models actually are, how they work at a topline level, and where their capabilities end.
Classify each task as language work or precision work before prompting
Matching the tool to the job leverages LLM fluency while routing math, counting, and fact-finding to reliable methods.
Verify all citations, numbers, dates, names, and high-stakes claims against sources
Fluent output can be confidently fabricated, so checking verifiable specifics prevents costly errors like fake legal citations.
Ground the model by pasting source text and restricting answers to it
Predicting from fetched text beats predicting from memory, dramatically reducing hallucinations on recall-heavy tasks.
Write specific prompts with examples, roles, and format constraints
The model only predicts from tokens you give it, so specific input sharply narrows guesses and improves output quality.
Instruct the model to use tools for math and web search for facts
Forcing code execution and live search routes precision tasks away from unreliable pattern-completion toward verifiable computation.
Set temperature low for factual work, high for creative brainstorming
Deliberate temperature control trades consistency against creativity, matching randomness to the task's tolerance for variation.
Restate key instructions near the start or end of long inputs
Models lose details buried mid-context, so placing critical instructions at the edges prevents "lost in the middle" failures.
Summarize decisions to bullets and paste into fresh chats
Long chats push out early context, so summarizing reclaims token budget and preserves work across a clean session.
Treat every AI answer as a draft you edit
Positioning yourself as final check, not passive publisher, keeps human judgment as the safety net against confident errors.
Request [VERIFY] flags on any checkable claims in output
Prompting the model to mark uncertain items surfaces risky content for review instead of hiding it in fluent prose.
Budget token usage against context limits using the tokenizer
Understanding roughly four characters per token drives pricing, context planning, and explains quirks like miscounting letters.
Prompt engineering
The practical craft of getting great results: structuring prompts, giving examples, asking for step-by-step reasoning, and iterating fast.
Structure prompts with role, context, task, and constraints
The four parts remove guesswork and turn generic, forgettable output into targeted, useful responses.
Name the audience explicitly in every prompt
Specifying who the output is for is the fastest single quality boost you can add.
Provide two or three consistent worked examples for tricky formats
Showing balanced examples teaches patterns better than paragraphs of rules and keeps the model neutral and on-format.
Name the exact fields and format, matched to the destination
Specifying columns, keys, and format (list/table/CSV/JSON) yields data you can use instead of walls of text.
Define how missing data is handled in structured output
Telling the model to use null or N/A for blanks prevents invented values and inconsistent rows.
Use API structured output or JSON mode for automated work
JSON mode guarantees a consistent shape every time, which manual prompting cannot reliably ensure for repeated tasks.
Add "think step by step" and label the final answer last
Explicit reasoning flips risky guesses into checkable chains, and a labeled final answer lets you skim to verify.
Pick a dedicated thinking model for genuinely hard problems
Reasoning models do chain of thought automatically, handling complex tasks better without manual prompting tricks.
Make one change per turn without repeating context
Small surgical edits are easy to steer and undo, and the model already remembers the chat.
Say "keep everything else the same" for surgical edits
This prevents surprising full rewrites that ruin the parts you already liked.
Split multi-part requests into one job per prompt
The model does each task better when focused, and you can verify each handoff before proceeding.
AI in daily work
Turning AI into a genuine productivity multiplier for writing, analysis, research, and admin, plus the judgment to know when not to use it.
Beat the blank page by generating a rough draft first, editing second
Drafting-then-editing eliminates the biggest everyday time-sink and starts you from a version rather than zero.
Refine drafts through follow-ups like "warmer," "shorter," not perfect first prompts
Iterative conversation produces higher quality faster than laboring over one exhaustive prompt.
Name tone precisely, e.g. "confident but not arrogant," over "make it nicer"
Precise tone labels steer voice reliably, whereas vague adjustments produce generic, unpredictable results.
Feed the AI samples of your real writing to match your voice
A voice snapshot escapes the generic-robot tone and makes output sound authentically like you.
Standardize one reusable meeting-summary prompt with TL;DR, decisions, and owned action items
A consistent format reused after every meeting is what actually saves hours each week.
Triage and summarize email before replying to anything
Sorting first beats replying randomly, focusing your effort on what genuinely matters.
Use approved enterprise AI tools; never paste confidential data into consumer chatbots
Enterprise versions keep sensitive material private, protecting you from data leaks and policy violations.
Ask "draft or final?" and "can I verify quickly?" before trusting output
This two-question triage sorts green low-risk tasks from red accountable ones needing verification.
Catch the silent draft-to-final shift before shipping unchecked numbers
The moment an unverified AI figure lands in a shipped document, it becomes your accountable answer.
Save every winning prompt into a named, categorized library
Naming as you go turns one-off wins into permanent reusable assets instead of a junk drawer.
Set 5-6 custom instructions once so every chat starts prepared
Standing role and style rules make each conversation begin halfway done without repeated context.
Responsible & trustworthy AI
Using AI safely and ethically: bias, verification, confidential data, copyright, and the topline of AI governance and the EU AI Act.
Run a counter-test by swapping names or genders in identical prompts
If the answer changes, the model is biased for that task, revealing hidden skews before they affect real decisions.
Add anti-stereotype instructions to your custom GPTs, Projects, and Gems
Building guardrails into your setup nudges every response, not just one, countering hidden defaults systematically.
Keep a human accountable for any AI decision about a person
Hiring, lending, health, and evaluation carry legal and ethical stakes AI cannot own; a confident model quietly carries past unfairness forward.
Tier every task by asking what happens if it's wrong
Matching verification effort to stakes lets you glance-and-go on trivia while independently confirming medical, legal, and financial work.
Transform AI output meaningfully before treating it as yours
Pure AI output usually isn't copyrightable in the US; substantial human contribution creates the value and legal protection.
Avoid trademarked characters, logos, and named living artists' styles in published work
You remain liable for infringing output even when the AI generated it, exposing you to legal risk.
Read each tool's commercial terms before using output for clients
Firefly is safest for client work while Midjourney and OpenAI grant paid users commercial rights; terms determine what you may sell.
Redact sensitive data with placeholders when no enterprise tool exists
Swapping real names, emails, and numbers lets the AI still work while keeping confidential data off someone else's servers.
Disclose AI assistance when it would change how work is trusted
Transparency on published content and decisions about people preserves trust and meets school, journalism, and contract requirements.
Never clone a real person's voice, face, or likeness without documented consent
Unconsented likeness use is legally and ethically dangerous, and increasingly regulated as prohibited or high-risk activity.
Run three-question triage—prohibited, high-risk, talking to people—before rolling out any tool
This catches the biggest EU AI Act compliance issues in minutes and forces the right first question every time.
Building with AI
How to structure an AI project, navigate the tools landscape (RAG, agents, vector databases, APIs), write basic code, and evaluate outputs against cost and latency.
Frame the job, user, metric, and simplest fix before building
Answering the four framing questions prevents months wasted building something nobody asked for.
Start at the lowest capability level that solves the problem
Climbing up is easy; ripping out an over-built chatbot is painful and public.
Earn your way up prompt, RAG, agent, then fine-tune
Each rung adds cost and complexity, so only climb when the simpler approach provably fails.
Use RAG for facts and fine-tuning for style
Confusing the two is the most common and expensive AI-building error teams make.
Skip RAG and paste small document sets into the prompt
Large context windows handle a few docs without the overhead of a retrieval pipeline.
Hand-label 100 real examples and score against them
A concrete test set replaces opinions with an honest number telling you what to fix.
Scope tight and write down explicit exclusions
Five fields from twenty vendors ships this week; "all invoices" never ships at all.
Open thirty real data samples before building anything
Auditing representative, labeled, legally-usable data prevents demos that collapse on messy real inputs.
Re-run your eval after every prompt or model change
Tracking the score over time catches silent regressions before they reach production unnoticed.
Store API keys in environment variables, never in files
Guarding keys like passwords stops accidental exposure when you share code.
Give agents read-only tools and confirm irreversible write actions
Guardrails and human confirmation stop buggy or tricked agents from causing irreversible damage.
Cap the agent loop and log every step
A capped, logged loop prevents runaway agents and shows exactly what actually happened.
Use small fast models in batch for high-volume easy work
Classification on a small model can be fifty times cheaper with negligible quality loss.
Use abstraction tools to avoid model and database lock-in
Swapping between Claude, GPT, or Pinecone later avoids a costly full rebuild.
ChatGPT & the OpenAI Ecosystem
A deep, hands-on mastery path for ChatGPT: models and Projects, Custom GPTs, Actions and Connectors, data analysis and multimodal, Codex and Canvas, agents, the OpenAI API, automation, and a capstone.
Route reasoning models to plan and cheap fast models to execute steps
Splitting agent roles keeps agents both smart and affordable, avoiding flagship cost on every trivial tool call.
Prompt reasoning models with goal, constraints, and definition of done
Reasoning models degrade when handed manual step lists; stating outcomes and telling them to flag uncertainty yields better results.
Cap reasoning effort and default to fast models, escalating deliberately
Invisible reasoning tokens make these models cost more than their rate implies, so escalation must be intentional.
Run one Project per client, scoping files and instructions to it
Isolated per-workstream context keeps client data from leaking across history and inherits the brief in every chat.
Reserve global memory for durable personal defaults, not project specifics
Separating universal role and style from per-engagement rules prevents contradictions and stale context bleeding across work.
Toggle off every custom GPT capability not required by the task
Each enabled tool is more room to wander; internal Q&A GPTs work best with everything off plus tight instructions.
Own team GPTs at workspace/admin level and publish workspace-only
Personal ownership dies at offboarding, and workspace-only sharing contains internal assistants from leaking to the public Store.
Run a pre-launch checklist covering data classification, identity, audit, and source of truth
A structured gate catches confidential exposure and confident hallucinations before a GPT reaches its audience.
Write Action operationId, summary, and description as when-to-use prompts
These fields are how the model decides which API to call; vague docs produce malformed or missed requests.
Use OAuth for user-scoped or write Actions; API keys only for shared read-only
Matching auth to identity needs and keeping endpoints read-only shrinks the blast radius of any misfire.
Profile data shape, nulls, and duplicates before transforming, demanding before/after row counts
Profiling-first cleanup based on facts and audited counts prevents silent row drops that quietly halve totals.
Download sandbox files and charts immediately after each analysis run
The Advanced Data Analysis sandbox is ephemeral and offline, so unsaved outputs are lost to expiry.
Extract long documents by schema with a final count and reconciliation
Per-clause fields plus a demanded count turn silent omission from invisible into measurable and auditable.
Chunk documents on semantic boundaries, never arbitrary character counts
Splitting on Articles or Sections and processing each with an identical schema preserves meaning and comparability across chunks.
Write an AGENTS.md with install, test, lint, and off-limits directories
This single small file is the highest-leverage setup step, dramatically improving PR quality and keeping CI green.
Set branch protection requiring PR, review, and passing checks before Codex runs
Existing merge gates physically prevent an agent from merging unreviewed code, inheriting the same guardrails as human PRs.
Run autonomous loops only with a machine-checkable done condition and hard caps
Tests, lint, or exit codes plus iteration and budget ceilings stop an agent thrashing on unsolvable problems.
Review every diff for the deleted-failing-test cheat and scope creep
Loops that pass by disabling checks are the classic cheat; review quality, not agent speed, is the real bottleneck.
Trigger PR-review Actions with pull_request, never pull_request_target
Forked PRs then run without your secrets, so untrusted PR code never touches your OPENAI_API_KEY.
Prompt agents for a deliverable with exact columns and flag-unknowns rules
Run quality is set before it starts; specifying source requirements and forbidding guessing prevents fabricated cells.
Demand per-cell source URLs and spot-check at least one
Stale pricing and annual-vs-monthly confusion are common; thirty seconds of verification catches the usual wrong cell.
Write scheduled Tasks as complete standalone prompts specifying quiet-week behavior
No human answers questions mid-run, so tool, format, and empty-result handling must be fully pre-specified.
Use propose-then-commit gates with tokens for all high-stakes actions
The agent returns a proposal and a human approval releases the commit, ensuring a person owns every irreversible yes.
Set hard billing limits with separate API keys per environment
Capped spend, per-environment keys, and a watched usage dashboard turn a cost spike into a warning, not an invoice.
Start new code on the Responses API and read response.usage from day one
Responses is the default, and tracking usage while capping max_output_tokens keeps cost visible and bounded early.
Model systems as small specialist agents with handoffs and cheap-model guardrails
Focused specialists reason better than one bloated agent, and edge guardrails on fast models reject bad input before expensive runs.
Let the model own only generation; gather, validate, and deliver in code
Deterministic surrounding code makes scheduled jobs cheap, testable, and reliable when they run without you watching.
Claude & the Anthropic Ecosystem
A deep, hands-on mastery path for Claude: models and Projects, connectors, Skills, MCP, Claude Code, GitHub workflows, the Anthropic API and Agent SDK, automation, and a capstone.
Route tasks to Haiku, Sonnet, or Opus by cost and difficulty
Matching model tier to task avoids burning money on Opus or shipping slow, dumb results.
Tune model tier and thinking budget as two separate dials
A well-tuned Sonnet often beats an under-thinking Opus, saving cost without losing quality.
Enable prompt caching on repeated large-context calls
Caching the repeated prefix is the single biggest cost lever for repetitive large-context work.
Escalate to a stronger tier only on detected low confidence
Running cheap first then retrying on failure beats blanket upgrades across every call.
Version knowledge by replacing files, never uploading a second copy
Two versions in the knowledge panel guarantee contradictions and muddy Claude's answers.
Build a custom Style from your writing samples, matched per task
A task-matched Style enforces voice everywhere and can override weaker in-chat instructions.
Treat Artifacts as a live workspace, verifying by using not reading
Testing actual running behavior catches bugs a code listing hides.
Promote a tool to Claude Code once it needs secrets or a repo
Artifacts are a sandboxed front-end; forcing backend features into them fails.
Grant read-only connector scopes and revoke tokens at the provider quarterly
Least-privilege access and source-level revocation kill dormant risk that disconnecting in Claude alone leaves alive.
Name the tool sequence and sources explicitly when chaining connectors
Explicit ordering routes far more reliably than vague prompts, since connectors match your words to tool descriptions.
Apply the stranger-with-an-hour test before connecting any data source
Asking the worst reversible damage forces a clear risk decision before granting access.
Write a Skill's description with verbs, file types, and triggers
The description is routing logic, not a label, so Claude loads the Skill exactly when needed.
Choose a Skill over a long prompt for recurring rule-heavy tasks
Skills package stable, right-answer procedures in Git rather than relying on your memory each time.
Keep SKILL.md short, pushing detail into referenced helper files
Progressive disclosure and version control keep Skills maintainable and portable across surfaces.
Test a Skill's trigger with three real requests before polishing
Watching whether it fires on real phrasings turns each miss into one specific rule.
Enable file creation and name the format to trigger document skills
The xlsx, docx, pptx, pdf skills only produce real editable files with the toggle on and format named.
Write tool docstrings and type hints for the model's routing
Claude decides when to call a tool from its description alone, so vague docstrings cause wrong calls.
Build MCP servers as local stdio, then flip transport to remote
Debugging locally then changing one line to HTTP ships a connector without touching tool logic.
Scope every remote MCP query to the authenticated identity
Never letting model input become your security boundary prevents identity-confusion exploits.
Add a CLAUDE.md with test command, conventions, and off-limits directories
Durable context carried across sessions removes what you'd otherwise re-type every prompt.
Use plan mode to design the approach before any file changes
Correcting the plan when steering is cheapest prevents sprawling, unreviewable diffs later.
Write shareable slash commands for tasks you trigger repeatedly
Standardized commands turn repeated workflows into reproducible team infrastructure.
Enforce deterministic rules with PreToolUse and PostToolUse hooks
Hooks run real shell commands to auto-format or block forbidden actions instead of hoping the model complies.
Commit settings.json for shared guardrails, keeping personal overrides local
Cloning the repo reproduces the entire configured engineering environment on day one.
Fan out subagents only for wide, separable work
Broad audits and independent tasks suit isolation; refactors and single-bug hunts belong in one thread.
Brief every subagent completely and require evidence-bearing summaries
A fresh context cannot ask questions, and you only get the summary back to audit.
Put standing instructions in the API top-level system parameter
Claude is trained around this structure and follows system instructions more reliably than user turns.
Always check stop_reason and usage on every API reply
A reply cut off at max_tokens looks complete but isn't, and token counts drive cost and budget.
Stream replies whenever a human is waiting on output
Streaming keeps user-facing long responses responsive; use create() only for silent background jobs.
Force a tool schema when you need guaranteed parsed JSON
Setting tool_choice with enum and required locks output shape and returns already-parsed input.
Filter PR-review Action triggers with paths and opened events
Path filters and reviewing on opened rather than every synchronize cut token spend without losing coverage.
Make every scheduled run idempotent with dated outputs and done-checks
Retries or test runs then never produce duplicate emails or corrupted state.
Gemini & Google AI
A deep, hands-on mastery path for Gemini: models and the app, Gems, Workspace, Extensions, AI Studio and the Gemini API, Gemini CLI and Code Assist, agents, Vertex AI, automation, and a capstone.
Default to a Flash-first cascade, escalating to Pro only where decisions matter
Spending expensive reasoning capacity only on high-stakes steps controls cost and latency across multi-call workflows.
Send PDFs, images, audio, and video natively in one request
Native multimodality eliminates separate OCR or transcription pipelines and enables timestamp and cross-modal queries in a single call.
Stuff single large artifacts into long context, reserving RAG for large corpora
Long context gives more accurate answers with less code when the corpus fits; only build retrieval when scale forces it.
Match the surface to the stakes: AI Studio, API, Gems, then Vertex AI
Choosing the smallest surface that satisfies the job avoids drowning in cloud config before validating anyone wants it.
Build a Gem at the third repeat when setup is stable
A reusable assistant stops you retyping stable instructions while the input changes, and becomes a working spec for later automation.
Encode brand behavior as banned-word lists and before/after pairs, not adjectives
Explicit rules and examples make a Gem reliable for others, whereas vague instructions like "make it on-brand" fail.
Split Gem task structure from personal style saved in global info
Reference files and task rules belong in the Gem; durable personal facts in Saved info apply everywhere automatically.
Use @-mention extensions for app data, search grounding for public web facts
Reach and freshness are different needs; explicit invocation ensures the model calls the right tool for private versus public data.
Audit and fix Drive over-sharing permissions before enabling Gemini
Gemini reveals existing over-sharing rather than creating it, since interactive assistants act strictly as the user.
Chain Workspace apps so decks and replies build on real source files
Cross-app grounding anchors output to actual headers and thread history, reducing hallucination versus generic chatbot copy-paste.
Prototype visually in AI Studio, then Get code with an env-var key
Tuning temperature, schema, and grounding visually first means your first production run usually just works.