38 items
54. You Are the Senior Developer — The Agent Is the Junior
The most useful mental model for working with agents isn't "tool" and it isn't "collaborator" — it's "junior developer." Capable, fast, knowledgeable across a broad surface area, genuinely helpful ...
55. Agentic Programming Rewards the Lazy Thinker
Lazy, here, is a technical term.
56. The Goal Is Outcomes, Not Outputs
An agent that produces a beautiful summary of a document hasn't succeeded.
57. Automate the Boring Parts, Stay Close to the Interesting Parts
The highest-value use of an agent is freeing up human attention for the work that actually requires it.
58. Iteration Speed Is Your Competitive Advantage
The developers who improve fastest in agentic programming are not the ones who think most carefully before they act — they're the ones who act, observe, and adjust in the shortest cycles.
59. The Field Is Moving — Your Mental Models Must Too
The mental models you built six months ago are already partially wrong.
60. Learn to Read Failure Like a Detective, Not a Judge
When an agent fails, the instinct is to assign blame.
61. Agentic Programming Is a Discipline, Not a Shortcut
The pitch for agentic programming often sounds like a promise of less work.
62. The Hardest Skill Is Knowing When to Take Back the Wheel
Delegation to an agent is easy.
63. Discomfort with Uncertainty Is a Liability in This Field
Agentic systems are probabilistic, the field is young, and the right answer to many important questions is genuinely unknown.
64. Expertise Still Matters — It Just Shows Up Differently Now
There's a version of the agentic future where expertise is devalued — where the gap between the expert and the novice closes because both can prompt an agent to do the work.
65. The Best Practitioners Are Editors, Not Just Authors
Writing and editing are different skills, and most developers are much better at one than the other.
66. Patience with Ambiguity Is a Technical Skill
Ambiguity is uncomfortable.
67. Stay Curious About Failure
Failure in agentic systems is information.
68. Agentic Systems Expose Gaps in Your Own Thinking
One of the less-discussed effects of working with agents is how clearly they reveal the places where your own thinking is incomplete.
69. The Field Rewards Generalists Who Go Deep on One Thing
Agentic programming sits at the intersection of software engineering, system design, language and communication, domain expertise, and product thinking.
70. Don't Mistake Fluency for Understanding
You can become fluent with agentic systems without understanding them.
71. Build for the Agent You Have, Not the Agent You Wish You Had
Every developer working with agents has a gap between the current capabilities of the tools they're using and the capabilities they wish those tools had.
72. The First Version Should Be Embarrassingly Simple
Every lasting principle in software has a version of this at its core.
54. Vous êtes le développeur senior — l'agent est le junior
Le modèle mental le plus utile pour travailler avec les agents n'est pas « tool » et ce n'est pas « collaborateur » — c'est « développeur junior ».
55. La programmation agentique récompense le penseur paresseux
Paresseux, ici, est un terme technique.
56. L'objectif est les résultats, pas les outputs
Un agent qui produit un beau résumé d'un document n'a pas réussi.
57. Automatisez les parties ennuyeuses, restez proche des parties intéressantes
L'usage le plus précieux d'un agent est de libérer l'attention humaine pour le travail qui en a vraiment besoin.
58. La vitesse d'itération est votre avantage compétitif
Les développeurs qui s'améliorent le plus vite en programmation agentique ne sont pas ceux qui réfléchissent le plus soigneusement avant d'agir — ce sont ceux qui agissent, observent et ajustent dans les cycles les plus courts.
59. Le domaine évolue — vos modèles mentaux doivent suivre
Les modèles mentaux que tu as bâtis il y a six mois sont déjà partiellement faux.
60. Apprenez à lire l'échec comme un détective, pas comme un juge
Quand un agent échoue, l'instinct est de désigner un coupable.
61. La programmation agentic est une discipline, pas un raccourci
Le pitch de la programmation agentic sonne souvent comme une promesse de moins de travail.
62. La compétence la plus difficile, c'est de savoir quand reprendre le volant
Déléguer à un agent est facile.
63. L'inconfort face à l'incertitude est un handicap dans ce domaine
Les systèmes agentic sont probabilistes, le domaine est jeune, et la bonne réponse à plusieurs questions importantes est réellement inconnue.
64. L'expertise compte encore — elle se manifeste juste différemment maintenant
Il existe une version du futur agentic où l'expertise est dévaluée — où l'écart entre l'expert et le novice se referme parce que les deux peuvent prompt un agent pour faire le travail.
65. Les meilleurs praticiens sont des éditeurs, pas juste des auteurs
Écrire et éditer sont des compétences différentes, et la plupart des développeurs sont bien meilleurs à l'une qu'à l'autre.
66. La patience face à l'ambiguïté est une compétence technique
L'ambiguïté est inconfortable.
67. Reste curieux face à l'échec
L'échec dans les systèmes agentic, c'est de l'information.
68. Les systèmes agentic exposent les lacunes de ta propre réflexion
Un des effets moins discutés du travail avec des agents, c'est à quel point ils révèlent clairement les endroits où ta propre réflexion est incomplète.
69. Le domaine récompense les généralistes qui approfondissent un sujet
La programmation agentic se situe à l'intersection de l'ingénierie logicielle, de la conception de systèmes, du langage et de la communication, de l'expertise de domaine et de la réflexion produit.
70. Ne confondez pas la fluidité avec la compréhension
Tu peux devenir fluide avec les systèmes agentiques sans les comprendre.
71. Construisez pour l'agent que vous avez, pas celui que vous aimeriez avoir
Chaque développeur qui travaille avec des agents a un écart entre les capacités actuelles des outils qu'il utilise et celles qu'il aimerait que ces outils aient.
72. La première version devrait être embarrassamment simple
Chaque principe durable en logiciel a une version de ceci en son cœur.