Are we doomed? A developer's manifesto

When you have fifteen years of experience in the web industry, the current zeitgeist carries a very heady sense of déjà vu.

In the mid-2000s, the explosion of WordPress and the first mainstream CMSs caused exactly the same tidal wave: the sudden arrival of an abstraction layer so accessible it created the illusion that technical knowledge had become obsolete. Overnight, anyone could install a theme, stack plugins, and claim to deliver a web application. Even back then, op-eds were heralding the scheduled death of agencies and the end of developers.

Reality on the ground quickly issued a wake-up call. As soon as companies wanted to connect these tools to their enterprise systems, handle traffic spikes, or simply figure out why two plugins were colliding in the event loop, the house of cards collapsed. Without knowing how to read PHP documentation, audit an SQL query, or understand the lifecycle of an HTTP request, these sorcerer's apprentices found themselves petrified before the infamous White Screen of Death.
The industry didn't fire its developers: it paid them double to come in and defuse the technical debt accumulated through months of foundationless tinkering.

With today's language models, we are replaying the exact same scene, but on a staggering industrial scale:

"We have handed WordPress to the entire world before taking the time to explain what a code interpreter is."

The illusion of words and the mirage of sterile demos

The history of computing is an uninterrupted succession of abstractions. We went from punch cards to assembly, from assembly to C, from C to managed languages, and then to declarative frameworks like React. It's the eternal trajectory from Latin to vernacular languages: we simplify syntax, bring code closer to human thought, and widen the circle of builders.

With generative AI, abstraction crosses its ultimate threshold: natural language becomes the compiler.

Typing a prompt in English into a text box and seeing two hundred lines of clean code emerge in four seconds provides an intoxicating sense of superpower. But this typing speed anesthetizes critical thinking. We confuse syntactic recitation with software engineering. A statistical model is an information compressor of incredible virtuosity, capable of aligning probable tokens with perfect aplomb. But it has no causal model of the world: it has never browsed an application, does not understand the physical reality of network latency, and knows nothing of the consequences its architectural choices will have on a production system.

This illusion is masterfully maintained by the very nature of product demonstrations. Anyone who has ever prepared a technical pitch or a product launch in a dev agency knows the rule: you clear the path, inject sanitized datasets, and hide the forty failed takes where the system drifted off course.

When labs present models solving complex scenarios in one go, they are showing us a perfectly sealed laboratory beaker. Out in the field, software engineering is never a sterile environment.

Under the hood of "autonomy": the triumph of the while loop

For two years, the prevailing narrative has hammered home the imminent arrival of "autonomous agents" capable of steering projects from A to Z and replacing entire departments.

Yet, when we examine the concrete architecture of the most performant agentic tools on the market (like Claude Code or LLM-driven development environments), what do we find under the hood?

Absolutely zero spark of magic:

1. A statistical intent emitted as raw text by the LLM.
2. A deterministic script, running locally on the host machine, which captures this textual intent and executes a system tool (cat, grep, npm test, a linter).
3. The capture of standard output streams (stdout) and, crucially, system errors (stderr).
4. A good old while loop, framed by strict stopping conditions (max_loops = 3), try/catch blocks, and deterministic retry counters.

This is the absolute technical paradox of our time: to make the most sophisticated probabilistic technology ever conceived usable, we are forced to bridle it with the most elementary algorithmic structures of the 1970s.

A language model left to its own devices suffers from massive compliance bias. If you ask it to evaluate the quality of its own code, it will validate its own mistakes with disarming politeness. The only way to extract a stable result is not to add a second "supervisor" LLM, but to confront it with the guillotine of a binary referee that does not negotiate: a strict TypeScript compiler, a ruthless linter, an independent unit testing suite.

"The value of an engineer today does not lie in writing a poetic prompt, but in the ability to design a deterministic software harness to neutralize the entropy of the machine."

The abyss of cumulative complexity: 3 files vs. 1,000 files

Why does this disconnect remain invisible to those who marvel at demonstrations showing "a full SaaS built in two hours"?

Because there is a methodological abyss between generating an isolated script of eighty lines and maintaining a living architecture of over a thousand files.

• Context dilution: We are promised windows of one or two million tokens capable of ingesting entire repositories. But ingesting text data is not understanding it. This is the documented phenomenon of Lost in the Middle: the more the mass of context swells, the more porous the model's attention becomes. It forgets a naming convention set four hundred files earlier, gets tangled in the signature of a global hook, and hallucinates non-existent dependencies.
• The invisible graph and human memory: A living application is not just a sum of text files; it is a directed graph riddled with implicit knowledge. It's complex business rules, historical styling cascades, Varnish cache invalidations, and team compromises. This knowledge isn't explicitly written anywhere: it resides in the memory of the developers who steered the platform's compromises over the years.
• The massacre of field compromises: A production codebase is never pure or elegant. It stays upright thanks to pragmatic patches—a weird CSS workaround for an old mobile rendering engine, an asynchronous condition to absorb the latency of an aging third-party API. Trained on the theoretical, sanitized code of web tutorials, the model has the devastating reflex of wanting to "normalize" and refactor what it mistakes for anomalies, silently blowing up the levees that kept the system from imploding.

The anesthesia of consent: the fortress fallen in silence

While we debate syntax, an unprecedented security shift in the history of our industry has occurred right before our eyes.

For twenty years, we erected digital fortresses. Security teams mandated physical YubiKey policies, segmented networks, strict VPNs, and drastic compliance audits. The mere thought of inserting an unknown USB drive into a workstation or transmitting a password in plaintext triggered crisis meetings, haunted by the specter of ransomware and industrial espionage.

And in the span of two years, the entire industry opened the floodgates with a smile.

Millions of professionals—developers trying to close a ticket, CFOs pasting balance sheets before closing, lawyers submitting confidential contracts, HR teams analyzing salary grids—daily pour their companies' strategic know-how onto the servers of a few private conglomerates.

The psychological sleight of hand is fascinating:

• Ransomware strikes with a bang: a red screen, encrypted files, a countdown, immediate panic. The human brain identifies an attack and activates its defense reflexes.
• AI as a SaaS presents itself as a courteous, fast, polite assistant, available by the second.

"Ergonomic comfort instantly short-circuits our most elementary instinct for self-preservation."

Some will counter that large enterprises cover their bases with dedicated instances (Azure OpenAI, AWS Bedrock, or GCP Vertex), contractually isolated from public training streams. This is true, and these confidential enclave infrastructures represent impressive engineering work.

But what about the rest of the world?

What about the 95% of startups, SMBs, agencies, and freelancers who have neither these enterprise contracts nor the skills to audit these streams? They use mainstream interfaces or third-party tools hooked up to standard API keys, with zero certainty regarding data retention.

By pooling the intellectual property of hundreds of thousands of organizations into a handful of inference clusters, we have created the most attractive vulnerability point in cybersecurity history. And if a breach occurs tomorrow, who will bear the damages? The platforms' terms of service systematically limit their liability to the amount of subscriptions paid. Cyber insurance will exclude claims related to unapproved third-party tools. At the end of the chain, it is the local company and its developers who will bear the full legal and financial responsibility toward their clients.

The local trial by fire: pragmatism vs. dogma

Faced with this reality, the immediate reflex of a sovereignty-conscious engineer is crystal clear: cut the cord, bring the models in-house, and run everything on your own hardware (local-first).

I took the experiment all the way, configuring local architectures with specialized models and native runtimes. On paper, the promise is idyllic: zero bytes transmitted outside, zero marginal cost, total technological independence.

But as soon as you confront it with the imperatives of a real delivery day, material reality asserts itself:

• The mental and hardware tax: as soon as you expand the context window beyond a few thousand tokens, the fans scream, VRAM saturates, and inference throughput collapses to a handful of tokens per second on quantized models that lose their nuance on edge cases.
• The ergonomic comparison: meanwhile, on a smartphone or via optimized cloud APIs, frontier models respond in real-time, with millions of tokens of context, absolute fluidity, and surgical precision, without taxing the local machine's resources.

Trying to impose a 100% local practice on an entire technical team today is an operational dead end. A lucid posture rejects dogma to articulate two realities:

1. Pragmatic Cloud

• Environment: Hosted frontier models (Remote APIs).
• Use Case: Architecture brainstorming, drafting/debugging, public documentation, rapid prototyping.
• Operational Value: Raw power, typing speed, massive context.

2. Sealed Local

• Environment: Small models (SLMs) on air-gapped machine.
• Use Case: Parsing personally identifiable data, analyzing prod logs with IDs, confidential internal scripts.
• Operational Value: Absolute seal, zero leakage, uncompromised compliance.

Expertise now consists in knowing how to draw this sealed border: knowing exactly what we delegate to remote supercomputers, and what we imperatively keep locked within our own physical perimeter.

The classic trap: from the promised land to the subscription cage

Why is this engineering discourse so inaudible in the current uproar? Because lucidity doesn't fit the platforms' economic model.

On one side, content creators on social networks are prisoners of the attention economy: promising a fortune in two clicks or screaming that developers are dead generates millions of views; explaining how to configure a linter and manage complex state in JavaScript interests no one. On the other, AI labs have raised hundreds of billions of dollars from the markets. To justify such levels of capital, they cannot settle for selling a super-calculator to web engineers: they are forced to wave the messianic myth of AGI to fuel market valuations.

Yet, we are already seeing the secular mechanics of platform "enshittification" taking shape:

1. Loss-leader baiting: Quasi-free access to technologies costing fortunes in water and electricity, subsidized by venture capital to saturate working habits and create daily dependency.
2. Ecosystem lock-in: Once business processes are anchored to these proprietary interfaces, quotas tighten, pricing tiers skyrocket, and advanced features are gated behind stratified subscriptions.
3. The arrival of ad networks: How do you amortize server farms worth tens of billions of dollars without driving away users with prohibitive prices? Through the historic Web 2.0 model: injecting sponsored ads. Tomorrow, the prompt recommending a tech stack or a third-party library will subtly slip in the cloud solution of the commercial partner who paid to be featured at the heart of the statistical response.

In this very real cyberpunk landscape—where a few megacorporations rent out access to a centralized cognitive infrastructure—autonomous AGI is nothing but a marketing carrot. The players in this market have no interest in seeing the birth of an emancipatory, decentralized, and free tool that would run on any laptop. Their model relies on the tollbooth, not on user autonomy.

No, juniors are not doomed: they have the best tutor in the world

This is where we must break the ambient doom-mongering: no, junior developers are not an endangered species.

We have never needed them more. An industry that no longer trains juniors no longer produces seniors, and dies out in ten years. The real tragedy today doesn't come from the tool, but from how we are teaching them to use it.

If a junior uses AI like a code vending machine—pressing a button, copying the generated component, injecting it into the project without reading it, and moving to the next ticket—they are effectively signing their own professional death warrant. They lock themselves into the role of a precarious data-entry worker, incapable of explaining what they just delivered and terrified at the thought of the first bug in production.

But if they invert the dynamic, AI becomes the most powerful learning accelerator in the history of computing.

When I started out, understanding the internal workings of a pointer, an asynchronous event loop, or a reconciliation algorithm required scouring austere English documentation, asking intimidating questions on specialized forums, and sometimes waiting three days for a condescending reply.

Today, a junior has the most patient tutor in the world in front of them. A tutor available at 2 AM, whom you can ask the same question fifty times without ever facing judgment:

• "Explain line by line what this function does as if I were ten years old."
• "Why did you use an object reference here instead of a primitive value? What are the memory impacts?"
• "Pretend to be a strict compiler and show me where this code will throw a runtime exception."

"Those who adopt this rigor will not be replaced: they will become, in three years, developers with a technical maturity that took us ten years to acquire."

Reclaiming the pride of software engineering

Are we doomed? I don't think so.

Artificial intelligence is neither the end of our profession nor the miracle solution that will excuse us from understanding computer science. It is the most spectacular abstraction layer in software history, but it obeys the exact same laws as all those that preceded it.

Those who enter the profession thinking they can bypass algorithmic logic, data structures, memory management, and outage culture are setting themselves up for brutal awakenings. At the first major failure in production, at the first silent bug corrupting a critical database, they will find themselves exactly like that client fifteen years ago facing a white screen: incapable of understanding why the magical assembly fell apart.

The future does not belong to panic merchants, nor to prompt-miracle illusionists.

It belongs to lucid engineers. To those who open the PHP documentation before installing the CMS. To curious juniors who lean on the machine to dissect mechanisms rather than to flee the effort of thinking. And to professionals who exploit the raw power of these models to obliterate syntax drudgery, while keeping both hands firmly on the wheel, their minds locked on the foundations, and the technical competence necessary to hold the machine at bay.

This is not a taking of sides, but a reflection at a given point in time, a manifesto. Perhaps in six months, the umpteenth model will prove me wrong and AGI will have permanently replaced us—or perhaps this manifesto will still resonate.