30 items
1. Agents Are Not Magic, They Are Probability
An agent does not know things.
2. The Prompt Is the Architecture
Most developers treat the prompt as an afterthought — a thing you write once, probably badly, then tweak when something breaks.
3. Your Agent Is Only as Good as Its Context
Garbage in, garbage out is one of the oldest principles in computing.
4. Stop Anthropomorphizing, Start Debugging
When an agent does something unexpected, developers reach for human explanations.
5. Trust the Output, Not the Reasoning
Chain-of-thought reasoning is genuinely useful — it improves output quality, makes the agent's process more legible, and gives you something to debug when things go wrong.
6. Agents Fail Gracefully or They Don't — There Is No Middle
Most systems fail on a spectrum.
7. The Human in the Loop Is a Feature, Not a Weakness
There's a version of the agentic future where automation is the goal and human intervention is the failure mode — every step that requires a person to review, approve, or correct is friction to be ...
8. Know When to Use an Agent and When to Use a Function
Agents are impressive enough that it's tempting to use them for everything.
9. Determinism Is a Choice You Have to Make on Purpose
By default, language models are non-deterministic.
10. Your Agent Has No Memory Unless You Give It One
Every time you call a language model, it starts fresh.
11. Give Your Agent a Role, Not Just a Task
There's a difference between telling an agent what to do and telling an agent what it is.
12. Ambiguity Is Your Problem, Not the Agent's
When an agent produces an output that isn't what you wanted, the temptation is to say the prompt was ambiguous.
13. The Specification Is the Skill
The developers who get the most out of agents aren't the ones who know the most about models.
14. Review Agent Output Like You Review a Junior's Pull Request
The right mental model for reviewing agent output isn't proofreading — it's code review.
15. Conversation Is a Development Environment
The conversational interface to a language model isn't just a way to get answers — it's a place to think.
1. Les agents ne sont pas de la magie, ils sont de la probabilité
Un agent ne connaît pas les choses.
2. Le prompt est l'architecture
La plupart des développeurs traitent le prompt comme une pensée après-coup — un truc que tu écris une fois, probablement mal, puis que tu bricoles quand quelque chose casse.
3. Votre agent n'est aussi bon que son contexte
Garbage in, garbage out est un des plus vieux principes en informatique.
4. Arrêtez d'anthropomorphiser, commencez à déboguer
Quand un agent fait quelque chose d'inattendu, les développeurs se rabattent sur des explications humaines.
5. Faites confiance au résultat, pas au raisonnement
Le chain-of-thought reasoning est vraiment utile — il améliore la qualité de l'output, rend le processus de l'agent plus lisible, et te donne quelque chose à déboguer quand ça tourne mal.
6. Les agents échouent gracieusement ou pas — il n'y a pas de milieu
La plupart des systèmes échouent sur un spectre.
7. L'humain dans la boucle est une fonctionnalité, pas une faiblesse
Il existe une version du futur agentique où l'automatisation est le but et l'intervention humaine est le mode d'échec — chaque étape qui requiert une personne pour réviser, approuver, ou corriger est une friction à éliminer.
8. Savoir quand utiliser un agent et quand utiliser une fonction
Les agents sont assez impressionnants pour qu'on soit tenté de les utiliser pour tout.
9. Le déterminisme est un choix que vous devez faire délibérément
Par défaut, les LLM sont non déterministes.
10. Votre agent n'a pas de mémoire sauf si vous lui en donnez une
Chaque fois que tu appelles un LLM, il repart de zéro.
11. Donnez à votre agent un rôle, pas juste une tâche
Il y a une différence entre dire à un agent ce qu'il doit faire et lui dire ce qu'il est.
12. L'ambiguïté est votre problème, pas celui de l'agent
Quand un agent produit un output qui n'est pas ce que tu voulais, la tentation est de dire que le prompt était ambigu.
13. La spécification est la compétence
Les développeurs qui tirent le plus des agents ne sont pas ceux qui en savent le plus sur les modèles.
14. Révisez la sortie de l'agent comme vous révisez la PR d'un junior
Le bon modèle mental pour réviser l'output d'un agent, ce n'est pas la relecture — c'est la code review.
15. La conversation est un environnement de développement
L'interface conversationnelle d'un LLM n'est pas juste un moyen d'obtenir des réponses — c'est un endroit où penser.