JF Ramadier

Entrepeneur Software engineer #digitalhealth @ClinePlatform #cto #coding #machinelearning

[Nav Toor @heynavtoor]

You have noticed it. ChatGPT feels dumber than it used to. Your prompts that worked six months ago produce worse results now. The writing sounds flatter. The ideas sound safer. The internet itself feels like it is shrinking. Every article reads the same. Every email sounds the same. Every answer sounds like it was written by the same voice.

You thought it was you. It is not you.

Researchers at Oxford and Cambridge published a paper in Nature proving what is happening. They call it Model Collapse.

Here is the mechanism in one sentence. AI trained on AI-generated data gets dumber every generation until it forgets what real human data looked like.

The internet is filling with AI-generated content. Blog posts. Articles. Reviews. Comments. Social media. AI companies scrape the internet to train the next generation of models. Which means the next generation of AI is being trained on the output of the current generation.

Each cycle loses information. Not randomly. It loses the rarest, most unusual, most creative parts first. The researchers call these the "tails of the distribution." The weird ideas. The unexpected perspectives. The things that made the internet feel human. Those disappear first.

What remains is the average. The safe. The expected. The bland.

Then the next generation trains on that. And loses more. And the next generation trains on that. And loses more. The researchers proved this is not a slow decline. Major degradation happens within just a few iterations. Even when some of the original human data is preserved.

They tested it on large language models. On image generators. On statistical models. The pattern was the same every time. The output converges toward a narrow, flattened version of reality that looks nothing like the original data.

The lead researcher put it plainly. "Large language models are like fire. A useful tool. But one that pollutes the environment."

The pollution is invisible. You cannot see which sentence on the internet was written by a human and which was written by AI. Neither can the AI that is about to train on it. And once the tails are gone, they do not come back. The damage is irreversible.

This is not a prediction anymore. It is a diagnosis.

The internet you grew up on was built by humans writing things no algorithm would have written. Strange, personal, imperfect, alive. That internet is being diluted. One generation of AI at a time. And the models trained on what remains are learning a smaller and smaller version of the world.

Model Collapse is not a technical problem. It is a cultural one. The thing that made the internet worth reading is the thing that disappears first.

[JF Ramadier @JFRamadier]

Agree!

[Xudong Han @Xudong07452910]

这篇论文让我感觉，我们对「AI 会取代程序员」这件事的讨论方向可能全错了。

核心观点：AI Agent 的出现不是让软件工程师工作效率更高，而是让「把决策逻辑永久编码进软件」这件事本身变得越来越不必要。

作者说的是一个更根本的范式变化：传统软件工程的本质是，人类把判断逻辑「固化」成代码——if-else、状态机、算法，这些都是把人类决策「提前写死」的方式。但在以 LLM 为核心推理引擎的 Agent 系统里，代码变成了「临时生成、用完即扔的工具」，每次任务，Agent 动态生成需要的代码，执行完就不需要了。决策不再被预先编码，而是在运行时由 LLM 推理循环动态产生。这不是增量改进，而是软件生产范式的结构性替换。

我觉得这个观点里最值得注意的细节是：这不只是生产力工具的升级，而是「软件」这个概念本身的角色在变。以前代码是「系统的中心」，Agent 框架是外壳。现在 LLM 推理循环是中心，代码变成了外壳里的临时辅助。如果这个趋势持续，软件工程的核心能力可能不再是「写出好代码」，而是「设计出可靠的推理约束边界」。

以前我们关注写出可维护的代码，以后可能更要关注设计出可靠的推理边界。

https://t.co/28rZe5qvBP

[JF Ramadier @JFRamadier]

Pas étonnant !

[Jen Zhu @jenzhuscott]

Massive output uptick due to agentic AI. Complete flat adoption.

[Sick @sickdotdev]

Don’t make it so complex

[Kaito @KaiXCreator]

wow. Anthropic just dropped Opus 4.8, and i asked it to refactor my entire codebase

over 2 hours, 100 million tokens burned, complete architecture reset

none of it worked

but boy was it beautiful

[Wise @trikcode]

More and more startups choose AI Agents for basic tasks instead algorithms and automations.

[Florian Kronawitter @fkronawitter1]

Anthropic is too expensive and will either lose customers or cut prices

[Mark Ajzenstadt @mardehaym]

AI code is more dangerous than bad code.

A junior's mistakes are obvious. The naming is off, the style is messy, you see the shortcut from a mile away.

You know exactly where to look. Takes 5 minutes in review.

AI-generated code is clean, idiomatic, properly styled, and confidently wrong. The logic fails at the architectural level while looking production-ready on the surface. That's not a small difference. That's a different kind of problem.

22,000 developers tracked over 2 years. Bugs per developer up 54%. Review time up 200%. 31% of PRs now merge with zero review at all.

Not insufficient review. Zero.

And 25% of pull requests are now reviewed by other AI agents because teams figured they'd automate their way out of the bottleneck. It's not working.

You can't solve "code that fools humans" by adding more automation.

The bottleneck is senior engineers. They're the only ones reading past the syntax. And nobody's asking what happens when their review queue triples while leadership celebrates velocity metrics.

I wonder how many engineers are actually thinking before they press enter.

[JF Ramadier @JFRamadier]

@omartineau Il ne faut pas avoir de certitude en tout cas ! L’avenir le dira !

[JF Ramadier @JFRamadier]

Rendez-vous dans 1 et 2 ans pour vérifier la prédiction 😀

[Wise @trikcode]

2025 - 80% of code written by AI
2026 - 100% of code written by AI
2027 - 12% of code written by AI
2028 - 300% of bugs written by AI

[Florian Roth ⚡️ @cyb3rops]

I think AI coding hype follows roughly four stages:

1. Amazement

You try it and can’t believe how much code it generates from a few prompts.

2. Expansion

You start more and more projects because shipping suddenly feels cheap and fast.

This is also the phase where people start convincing everyone around them:

- coworkers
- management
- friends in other companies

because nobody wants to “fall behind” in 6–12 months.

That creates a massive snowball/FOMO effect.

3. The grind phase

You realize the generated code has architectural issues, sloppy mistakes, weird abstractions, duplicated logic, broken edge cases, etc.

So you start:

- re-prompting
- switching models
- increasing reasoning effort
- reviewing fixes
- generating fixes for previous fixes

And suddenly you spend your days reviewing AI-generated pull requests instead of building software.

4. Realization

You realize AI coding increases output much faster than it increases certainty.

The code still needs:

- review
- testing
- ownership
- architectural understanding
- long-term maintenance

Usually by expensive senior engineers.

And the interesting thing is:
this whole cycle can take many months or even more than a year because people become socially and professionally invested in the narrative themselves.

Once teams, managers, and entire companies have been convinced that this is the future, it becomes psychologically and politically very hard to later say:

“Actually, the ROI is much lower than we expected.”

[JF Ramadier @JFRamadier]

Tout cela me laisse perplexe!!!! Pourquoi autant de temps pour s’en rendre compte ?

[Laurence Devillers @lau_devil]

Claude code trop cher ! Microsoft s’en débarrasse ! Ne pas désapprendre à coder est essentiel

https://t.co/KYiVsE1a3B

[JF Ramadier @JFRamadier]

Wouah!

[Brandon Carl @brandonjcarl]

Very interesting data across 2,444 companies.

82% of tokens are spent on AI-generated bugs, rework and review friction.

[Gilles Babinet @babgi]

Pourquoi les offres d'emploi pour développeurs continuent-elles d'augmenter aux USA alors que l'IA automatise de plus en plus le développement logiciel ?
Probablement parce que le volume de code à produire augmente radicalement . La quantité de code produite et maintenue n'a jamais été aussi grande. Les dépôts de code sur les grandes plateformes collaboratives (gith-like) connaissent une croissance exponentielle.
En réduisant considérablement le coût de production du code, l'intelligence artificielle a rendu le développement logiciel accessible à un nombre bien plus grand d'entreprises, de secteurs et de projets. Des domaines qui n'envisageaient pas de créer leurs propres outils il y a encore quelques années s'y lancent aujourd'hui.
Paradoxalement, loin de faire disparaître les postes de développeurs, cette dynamique semble en créer davantage — ce qui devrait inciter à nuancer sérieusement le discours sur les destructions massives d'emplois annoncées par l'essor de l'IA, plus généralement.

[Pratham @Prathkum]

AI created the illusion that writing code is all it takes to be an engineer.

[JF Ramadier @JFRamadier]

Pas faux!

[Paul Lê @paulichon]

Le vrai skill en ia c’est de : savoir s’exprimer

[JF Ramadier @JFRamadier]

💯

[Brivael Le Pogam @brivael]

Un CEO qui n'est pas ingénieur et qui ne comprend pas en profondeur ses systèmes l'archi, le code, la tech est désormais useless.

Pourquoi ?

Parce qu'on entre dans un monde où l'intégralité des problèmes business peuvent être reframés comme des problèmes de code, exécutés par des IAs.

Un CEO sans background ingénierie atteindra grand max 6/10. 7 les très bons jours.

Et il n'y a plus de place pour les average.

Le SP7 de Marc Andreessen est réel. Les grands groupes vont se faire oblitérer un par un par leur équivalent AI-native, fondé par un ingé deep tech qui touche le code tous les jours.

Les CEO MBA qui pilotent à coups de slides et de "j'ai des bons CTOs" sont la prochaine génération de Kodak.

Le fossé ne se creuse plus entre les boîtes tech et les boîtes non-tech. Il se creuse entre les boîtes dont le CEO comprend ses systèmes et les autres.

[JF Ramadier @JFRamadier]

En effet, il va falloir se mettre d’accord !! 👍

[Emmanuel Parody 🇪🇺 🇺🇦 @eparody]

Il va falloir vous mettre d’accord les gars

[JF Ramadier @JFRamadier]

@Jouhatsu_ai Oui merci 🙏

[JF Ramadier @JFRamadier]

🤔

[Pau Labarta Bajo @paulabartabajo_]

Advice for AI engineers 💡

Stop building LangGraph pipelines.

Modern LLMs are so good at tool calling that your hand-crafted orchestration is actually hurting performance.

Let the model decide.