DEV Community: Nicolas Dabene

5 Claude Code Features That Many Developers Underutilize

Nicolas Dabene — Tue, 30 Jun 2026 16:00:06 +0000

Most developers use Claude Code as a simple assistant capable of generating code.

Yet, the biggest gains don’t come from code generation itself.

They come from how you structure the context, protect the project, delegate tasks, and manage the agent’s working memory.

After several weeks of intensive use, five features stand out: CLAUDE.md, Hooks, ultrathink, /compact, and Subagents.

Used together, they transform Claude Code from a simple conversational tool into a true AI-assisted development environment.

🧠 The Problem Is Almost Never the Model

When a developer claims that Claude Code produced bad code, the issue rarely lies with the model itself.

In most cases, Claude works with incomplete context, implicit rules it doesn’t know, or memory cluttered by hours of exchanges.

This is exactly the same problem as with a human developer joining a project without documentation, conventions, or an overview.

The difference is that a human eventually understands the environment over weeks.

The AI, however, starts almost from scratch with each session.

This is why the most important features of Claude Code aren’t those that generate code.

They’re the ones that structure its working environment.

📄 CLAUDE.md: The File That Avoids Repeating the Same Things

Many teams spend their time reminding the agent of the same information:

how to run tests;
which commands to use;
which conventions to follow;
which architecture to adhere to.

This is a considerable waste of time.

Claude Code offers a much simpler approach: place a CLAUDE.md file at the root of the project.

At each startup, the agent automatically reads this document and immediately retrieves the necessary context.

The benefit isn’t just about saving time.

The real advantage is reducing response variability.

When development rules are written in black and white, Claude no longer needs to deduce them. It applies them directly.

For complex projects, especially those with specific architectures or strong business conventions, this simple file quickly becomes one of the most valuable assets in the project.

🔒 Hooks: When Rules Become Automatic

Another common pitfall is asking the AI to follow certain rules while hoping it never forgets them.

This is rarely a reliable strategy.

Hooks allow you to move these rules out of the conversation to make them automatic.

Imagine a project containing critical files, environment variables, or infrastructure secrets.

Instead of constantly reminding Claude never to modify these elements, it becomes possible to technically block these operations.

The same principle applies to code quality.

Every modification can automatically trigger a linter, formatter, or a battery of checks before validation.

This shifts from a trust-based logic to a control-based one.

And as in any mature software architecture, automatic controls are generally more reliable than human reminders.

🤔 Ultrathink: A Resource to Use Sparingly

One of the most common mistakes is using deep reasoning capabilities for absolutely everything.

It’s tempting.

When a feature promises more reasoning, the instinct is to enable it permanently.

Yet, this is often counterproductive.

Requesting a complex architectural analysis to rename a variable is like convening the entire management committee to choose a button’s color.

Additional cognitive resources should be reserved for situations where they truly add value.

Architecture overhauls.

Particularly difficult debugging.

Risky technical migrations.

Analysis of a distributed system.

In these contexts, advanced reasoning mode can save considerable time.

For daily tasks, it mostly slows execution and increases context consumption.

As often in engineering, maximum power isn’t the optimal solution. The right strategy is to use the right power at the right time.

🧹 /compact: The Feature Many Discover Too Late

After several hours of work, a Claude Code session inevitably accumulates noise.

Logs.

Already resolved errors.

Abandoned hypotheses.

File excerpts that are no longer useful.

All of this consumes context and eventually degrades response quality.

The /compact command addresses this problem precisely.

It allows condensing the history while retaining only the truly important information.

But the mistake is running the command without prior thought.

The real trick is to explicitly guide the compaction.

Specify what should be kept.

Recall architectural decisions made.

Identify the project’s critical constraints.

The difference is huge.

Instead of getting a generic summary, you create a working memory optimized for the rest of the session.

👥 Subagents: The Feature That Scales

When a project becomes large, context becomes a precious resource.

Every file read, every log analyzed, and every library explored consumes part of this resource.

Subagents provide an elegant solution to this problem.

Rather than cluttering the main session with thousands of lines of logs or a full exploration of an external dependency, Claude can delegate this work to a secondary agent.

The latter performs its research in its own context space and returns with a usable summary.

The parallel with an engineering team is interesting.

The lead developer doesn’t necessarily read every line of documentation for every system component.

They delegate certain investigations to specialists and only retrieve the useful conclusions.

Subagents apply this exact principle to the world of AI agents.

🚀 The Real Productivity Multiplier

These features may seem independent.

In reality, they form a coherent system.

The CLAUDE.md file provides context.

Hooks ensure rule compliance.

ultrathink intervenes when complexity demands it.

/compact maintains a clean context.

Subagents absorb secondary tasks without polluting the main session.

Individually, each brings measurable gains.

Together, they completely change how you work with Claude Code.

Most developers are still trying to optimize prompts.

The most advanced teams are already optimizing the environment in which the agent works.

And that’s probably where the real competitive advantage lies today.

— Nicolas Dabène

Why You Should Almost Never Send a PDF, DOCX, or Image to ChatGPT or Claude

Nicolas Dabene — Sat, 27 Jun 2026 16:45:02 +0000

TL;DR

Most users try to reduce their AI bill by switching models.

GPT or Claude?

Pro version or API?

Smaller or larger context?

Yet in many cases, the real problem isn't the model.

The problem is what you send to it.

PDF, DOCX, PowerPoint, screenshots, images... all these formats were designed for humans. Not for LLMs.

Result:

more tokens consumed;
more context wasted;
higher costs;
sometimes even less relevant responses.

The best optimization is often not changing the model.

It's preparing documents better before sending them.

🚨 The Hidden Token Tax

When you send a document to an LLM, it doesn't "read" the file like you do.

Before even analyzing the content, it must understand:

where the text begins;
where the text ends;
which elements are headings;
which elements are paragraphs;
which areas represent a table;
which parts are decorative;
in what order the elements should be read.

In other words, some of your tokens are used solely to reconstruct the document's structure.

So you're paying for noise.

📄 Why PDFs Are Particularly Inefficient

PDF is probably the world's most popular document format.

But it was designed for printing.

Not for artificial intelligence.

A PDF mainly describes:

positions;
coordinates;
graphic blocks;
layout elements.

For a human, this is perfect.

For a model, it often requires preliminary reconstruction work:

determining the reading order;
reconstructing tables;
identifying headings;
understanding columns;
linking captions to images.

Some of the context is consumed before the business content is even analyzed.

📝 DOCX Files Aren't Much Better

Many think DOCX is naturally suited for LLMs.

That's not really the case.

A DOCX file contains:

text;
styles;
metadata;
layout information;
XML representation elements.

Even if the cost is generally lower than that of a complex PDF, a significant portion of the data sent doesn't directly contribute to understanding the document's business content.

🖼️ Images Are Often the Worst Case Scenario

The situation becomes even more costly when sending:

screenshots;
photos;
scanned documents;
slides exported as images.

Before understanding the content, the model must:

detect text;
perform OCR;
identify important areas;
reconstruct the logical structure.

You're asking the model to solve a vision problem before even addressing the business problem.

It's like photographing a sheet of paper and then asking someone to copy it before reading it.

📊 Not All Formats Are Equal

If the goal is to efficiently transmit information to an LLM, some formats are much better suited than others.

Format	Useful Signal	Structural Noise	Token Impact
Markdown	Very High	Low	Excellent
TXT	High	Very Low	Excellent
DOCX	Medium	Medium	Fair
Native PDF	Medium	High	Poor
Scanned PDF	Low	Very High	Very Poor
Image	Low	Extremely High	Catastrophic

This table summarizes a simple principle:

The closer a format is to structured plain text, the more efficient it is for an LLM.

💰 The False Debate: Changing Models

Most discussions revolve around questions like:

Which model consumes the least?

Which provider is the cheapest?

Which subscription offers the most context?

These questions matter.

But they often come too early.

Because before optimizing the engine, you need to optimize the fuel.

Reducing a model's cost by 30% is interesting.

Reducing the tokens sent with each request by 30 to 40% is often much more cost-effective.

And it generally improves response quality.

🚀 A Smarter Approach: Preparing Documents for LLMs

For a few months now, a new category of tools has begun to emerge.

Their goal isn't to create a new model.

Their goal is to better represent documents for existing models.

This is exactly the philosophy behind the DocLang project:

https://github.com/doclang-project/doclang

DocLang is an open-source project supported by the Linux Foundation AI & Data that starts with a simple observation:

PDF was designed for printing;
DOCX for editing;
HTML for display;
none of these formats were designed for LLMs.

DocLang's goal is therefore to provide an intermediate representation better suited to artificial intelligence.

Specifically, DocLang preserves:

document hierarchy;
headings;
sections;
tables;
metadata;
logical relationships between elements.

While removing much of the noise related to visual presentation.

The result:

more compact documents;
fewer tokens consumed;
better content understanding;
more effective context for AI agents and RAG pipelines.

According to figures published by the project, this approach significantly reduces the volume of tokens needed to represent a document while preserving its semantic structure.

🎯 The Real AI Challenge in 2026

For a long time, we optimized infrastructure.

Then we optimized models.

The next step is to optimize data.

In many AI projects, the biggest waste doesn't come from the model used.

It comes from how documents are prepared before ingestion.

Before searching for the next miracle model:

look at your prompts;
look at your workflows;
look at the files you send.

Because the easiest way to reduce your AI bill is often not to change models.

It's to stop sending it noise.

E-commerce Compliance: Why Some PrestaShop Modules Become Essential Building Blocks

Nicolas Dabene — Sat, 20 Jun 2026 08:00:02 +0000

Introduction: E-commerce Enters a New Phase

For a long time, the success of an online store has been associated with highly visible aspects: catalog performance, checkout optimization, SEO, or traffic acquisition. These elements remain fundamentally important, but modern online commerce now relies on a much broader set of constraints.

An e-commerce store is no longer just a showcase for selling products. It is an environment where customer experience, regulatory obligations, security, data protection, and technical quality converge. Even the slightest regulatory change can have concrete consequences on how a merchant must design their user journey.

The right of withdrawal is a particularly interesting example of this evolution. On paper, it is an obligation that merchants have long been aware of. In practice, integrating it into a PrestaShop store requires considering multiple dimensions: customer information, accessibility of the action, user journey, and consistency with the existing technical architecture.

It is in this context that certain modules take on particular value. Not because they add a spectacular feature, but because they transform a complex constraint into a simple experience for both the merchant and their customers.

The MedRetractation module, developed by Mediacom87, perfectly illustrates this approach.

Module link: https://www.prestatoolbox.fr/fonctionnalites-front-office/486-medretractation-bouton-de-retractation-legal-conformite-au-droit-de-retractation.html

When Compliance Becomes a Development Issue

Compliance in e-commerce has often been seen as a purely legal matter. However, in an online store, a regulatory obligation almost always ends up becoming a technical problem.

Information must be displayed in the right place. An action must be accessible. A journey must be adapted. Data must be stored or displayed correctly. Behind every business rule lies an implementation.

This is precisely where the expertise of a PrestaShop editor becomes crucial.

The merchant’s role is not to analyze regulatory changes, understand the subtleties of hooks, modify their theme, or maintain compatibility with different versions of the solution. Their job is to run their business.

The editor’s role is to take this complexity and make it invisible.

A good module is therefore not just an additional feature installed in a store. It is a layer of expertise that solves a specific problem without requiring the merchant to become a developer.

The Invisible Work Behind a PrestaShop Module

What is interesting about the work done by editors like Mediacom87 is that the real value of the product is not limited to what is visible in the interface.

Creating a PrestaShop module that meets a business need requires understanding multiple things simultaneously: the platform, merchant habits, technical constraints, version updates, and end-user expectations.

The difficulty is not just making a feature work today. The real challenge is creating a solution that continues to work tomorrow.

In the PrestaShop ecosystem, maintenance is essential. A store can remain in production for several years. A module must therefore evolve with it, keep up with version changes, and avoid becoming technical debt.

This is part of the editors' work that often goes unnoticed when everything functions correctly.

And ultimately, this might be the best sign of quality: when complexity disappears entirely for the end user.

MedRetractation: An Example of a Problem-Focused Module

What I find interesting about MedRetractation is not just the functionality it offers, but the problem it solves.

The module does not seek to transform the shopping experience with an additional marketing feature. It addresses a concrete need for merchants: properly integrating a legal obligation into the customer journey.

This approach represents a current trend in the e-commerce ecosystem. The best tools are not always those that add the most features, but those that reduce risks, simplify operations, and allow merchants to focus on their business.

In an environment where regulatory and technical expectations are increasing, these specialized building blocks are gradually becoming indispensable.

PrestaShop’s Strength Also Lies in Its Editors

One of PrestaShop’s great strengths is its ecosystem. The platform allows merchants to adapt their store to a wide variety of needs thanks to the modules developed around it.

But this ecosystem only works because editors invest time in creating and maintaining specialized solutions.

Behind every useful module, there is an understanding of the field: the problems merchants face, the technical constraints, and the necessary updates to keep a store reliable over time.

MedRetractation is a good example of this category of modules that do not necessarily seek to be the most visible but address a real operational need.

Conclusion: Value Often Lies in the Problems No One Wants to Handle

The future of e-commerce will not be built solely around new visible features. It will also depend on the ability to properly manage all the complexity behind an online sale.

Compliance, security, and reliability are becoming differentiating factors.

In this context, the role of PrestaShop editors becomes even more important: transforming sometimes complex constraints into simple, maintained, and accessible solutions.

This is exactly the kind of work that helps make an ecosystem like PrestaShop sustainable.

Contrib.: When Media Must Evolve with Communities

Nicolas Dabene — Thu, 18 Jun 2026 03:45:03 +0000

Introduction

We live in a time when access to information has never been easier. In just a few seconds, it’s possible to find an analysis, a video, a podcast, or a summary on almost any topic. Yet, this abundance creates a new challenge: it’s no longer information that’s lacking, but our ability to understand it, sort through it, and give it meaning.

Current technological transformations, particularly around artificial intelligence, are profoundly changing our relationship with knowledge. Tools are becoming increasingly powerful and accessible, but the real value is gradually shifting toward the ability to analyze, question, and participate in the decisions that will shape our future.

It’s in this context that the Contrib. initiative is interesting. The project doesn’t position itself solely as a podcast or a media outlet covering tech, business, and digital sovereignty. It seeks to experiment with a different relationship between those who produce information and those who consume it.

From Audience to Community

For a long time, the traditional media model relied on a fairly simple relationship: people produced content, and an audience came to consume it. This model enabled the creation of many benchmarks, but the digital world has deeply changed expectations.

Today, a community no longer just wants to receive information. It wants to understand, exchange, challenge ideas, and sometimes participate directly in shaping the topics. The value is no longer found solely in the published content but also in the interactions it sparks.

This is precisely what makes Contrib.’s approach so interesting. The project’s name itself carries an intention: to put contribution at the center. The idea isn’t just to create a media outlet that talks about transformations but a space where those involved can participate in the reflection.

This approach echoes certain principles found in the open-source world. A project doesn’t progress solely thanks to its initial creators but through all the people who use it, test it, propose improvements, and enrich the ecosystem.

Technology Advances, but Understanding Remains Essential

Artificial intelligence perfectly illustrates this evolution. Models are now capable of producing text, images, code, or analyses at an impressive speed. But having a powerful tool doesn’t automatically mean knowing what to do with it.

The central question is no longer just: "What technology is coming?" It has become: "How will we intelligently integrate it into our professions, businesses, and society?"

Specialized media thus have an evolving role. Their mission can no longer be limited to reporting on new developments. They must help us understand the implications, provide context, and enable people to step back from rapid changes.

This is also why topics around digital sovereignty are becoming important. Sovereignty isn’t just about infrastructure or data. It’s also about our collective ability to understand the tools we use and to avoid letting only a few actors decide the direction we take.

Building the Reflection Spaces of the Future

The next generation of media will likely be defined less by the quantity of content produced than by the quality of the communities built around that content.

In a world where artificial intelligence will be able to generate ever more information, what will become rare is high-quality human exchange: discussions, shared experiences, constructive disagreements, and the ability to develop a common vision.

Initiatives like Contrib. are exploring this direction by trying to bring media closer to its community. Content becomes a starting point, not an end in itself. Discussion becomes an integral part of the value created.

This is an interesting evolution because major technological transformations won’t be defined solely by the tools we use. They’ll also be defined by the spaces we build to discuss them and the collective decisions we make.

Conclusion

We cannot stop the transformations that are coming. Artificial intelligence, new technologies, and new economic models will continue to evolve.

However, we can choose our stance in the face of these changes. We can be mere spectators, or we can actively participate in shaping the future.

The approach taken by Contrib. offers an interesting perspective: in a world where information is becoming abundant, contribution may become a new form of value.

Understanding the future isn’t just about observing it.

It’s also about taking part in building it.

The Sovereignty of E-Commerce: Why Open Source Could Be Tomorrow’s True Answer

Nicolas Dabene — Wed, 17 Jun 2026 16:30:02 +0000

Introduction: After AI Sovereignty, E-Commerce Sovereignty

For the past few months, one word has been coming up more and more in discussions about artificial intelligence: sovereignty.

Who owns the models?
Who controls the data?
Who sets the access rules?
What happens when a critical technology depends on an external player?

These questions don’t just apply to AI.

They’ve existed for a long time in the world of e-commerce.

When a merchant builds their business on a platform, they make a strategic choice. They choose a technical foundation, an ecosystem, a vision of digital commerce.

And behind this choice lies a fundamental question:

Are we the owners of our digital commerce, or merely users of a service we depend on?

This is precisely why the future of open source in e-commerce deserves close attention.

A Question I Receive Regularly: Is PrestaShop Still Viable?

Lately, I’ve received several messages from merchants asking a simple but revealing question:

"Is PrestaShop still viable today?"

This question doesn’t come out of nowhere.

The e-commerce market is accelerating. Artificial intelligence is transforming usage. Architectures are evolving. Major cloud and SaaS platform players are strengthening their positions.

In this context, some may feel that historical open-source solutions are doomed to disappear.

My answer is clear:

Yes, PrestaShop is still viable. In fact, I think we’re at a new stage in its history.

Not because the past must be preserved at all costs.

But because open source addresses an issue that is becoming increasingly important: maintaining control.

The Acquisition of PrestaShop: A Transition to View Differently

The acquisition of PrestaShop by the ecosystem led by cyber_Folks, Sylius, and BitBag has naturally sparked many reactions.

Some saw it as a loss of independence.

For my part, I think we need to look at this development through a different lens.

The issue isn’t just about who owns a company.

The real issue is understanding the direction the ecosystem is taking.

And what’s interesting today is the meeting of two complementary worlds.

On one side, PrestaShop has a strong history in online commerce, with a community, thousands of stores, and an ecosystem built over the years.

On the other, Sylius offers a more modern vision of e-commerce development, with a framework-oriented approach, flexibility, and scalable architectures.

This combination could open a new chapter.

Not the disappearance of PrestaShop.

An evolution.

The challenge isn’t to remain frozen in what e-commerce was ten years ago.

The challenge is to build the foundation for the next ten years of e-commerce.

Open Source as a Strategic Answer

In a world where businesses are becoming dependent on technological building blocks they don’t always control, open source offers something rare:

the ability to understand, adapt, and evolve your tool.

This doesn’t mean open source is magical.

An open-source solution can fail if it doesn’t evolve.

It can become obsolete if its community disappears.

It must continue to innovate.

But it has a structural strength: it doesn’t rely solely on a commercial promise.

It relies on an ecosystem.

This is also why the activity around PrestaShop remains an important signal.

Communities like Friends of Presta continue to unite field players. Events like EO2S 2026 show that there’s still energy around this technology.

A living project isn’t just source code.

It’s a community that continues to build.

The PSE: A Negative Signal or a Difficult Choice in a Time of Acceleration?

The announcement of PrestaShop’s PSE (Performance and Sustainability Plan) has obviously raised concerns.

This is understandable.

When a company reduces its workforce, the first reaction is often to interpret it as a sign of retreat.

But I think we should also consider this decision in the current context.

The tech industry is going through a period of brutal transformation.

Artificial intelligence is changing development methods, production cycles, user expectations, and business models.

In this context, all organizations must rethink how they operate.

This doesn’t automatically mean the end.

It can also be an attempt at deep transformation.

Is it a risky bet? Yes.

But sometimes, not changing is an even greater risk.

The Interesting Signal: PrestaShop Begins to Look at the AI Era

Another element seems particularly interesting to me: the presence of the .ai directory in the PrestaShop repository.

This is not a trivial detail.

The e-commerce of tomorrow won’t just be a store with a catalog and a checkout process.

It will be augmented by agents, assistants, automations, and systems capable of helping make decisions.

The real question will then be:

Who will control these intelligences?

A closed platform that imposes its own rules?

Or an open ecosystem where merchants can choose, adapt, and integrate their own solutions?

E-commerce sovereignty and AI sovereignty will likely converge.

Will the Future of E-Commerce Be Open?

I don’t think the future will simply pit open source against SaaS.

Both models will likely continue to coexist.

But in a world where every business is becoming dependent on its digital tools, the ability to maintain control is becoming a strategic advantage.

E-commerce is no longer just about selling online.

It’s a question of infrastructure.

And critical infrastructure must be mastered.

This is why I believe PrestaShop, with its history, its community, and this new phase alongside players like Sylius, has an important card to play.

Not by looking at the past.

But by building the next chapter.

The real question may no longer be:

"Which platform should we choose?"

But rather:

"Who do we want to let control the digital commerce of tomorrow?"

PrestaShop #OpenSource #Ecommerce #AI #DigitalSovereignty

The CRT Method for Developers: Mastering the Art of Prompt Engineering

Nicolas Dabene — Sun, 07 Jun 2026 09:00:03 +0000

1. Introduction: Moving Beyond the "Fuzzy Prompt" in Development

In today's software engineering ecosystem, productivity no longer depends solely on mastering syntax but on the ability to transform a vague intention into an actionable technical instruction. The major challenge developers face isn’t what they ask AI, but the imprecision of the request.

When a developer submits a "Fuzzy Prompt," the AI instantly becomes a guessing machine. It must fill in the user’s gaps by improvising on technical level, coding standards, or architectural constraints. For developers, this "guesswork" translates into costly operational friction: off-topic code, immediate technical debt, or dangerous hallucinations in business logic. The CRT method (Context, Role, Task) acts as a "mini-request architecture," structuring the exchange to shift from a mere text generator to a true engineering partner.

2. Anatomy of the CRT Method: Context, Role, Task

The CRT method is a minimal framework designed to eliminate ambiguity. In prompt engineering, the goal isn’t to write novels but to clarify critical variables so the AI stops interpreting and starts executing.

Breakdown of the Three Pillars

Context: Defines the request’s environment. Who is the target audience? What is the tech stack? What is the overall goal? Context fuels the response by providing the necessary data for reasoning.
Role: The identity adopted by the AI calibrates tone, precision level, and standards. Requesting an expert role avoids outdated solutions (e.g., PHP 5.6 instead of 8.2) and ensures professional rigor.
Task: The precise action. Pro tip: The "next-level" approach is to not ask for the final code immediately but to first demand a plan, structure, or clarification questions.

Summary: Fuzzy Prompt vs. CRT Prompt

Aspect	Fuzzy Prompt (Guessing Machine)	CRT Prompt (Engineered Request)
Example	"Help me with an API."	C: Beginner video on digital culture. R: Technical popularization expert. T: First propose a structured script outline.
Effect	AI improvises level and format.	AI produces a result aligned with the goal.
Risk	Hallucinations and mismatched code.	Surgical precision and time savings.

This structure is the bulwark against unusable results that clutter the development cycle.

3. Practical Case 1: Developing a Prestashop Module

Working with a CMS like Prestashop requires strict contextual rigor to avoid code incompatible with modern versions (Prestashop 8.x).

CRT Application

Prompt:

Context: Creating a promotions management module for Prestashop 8.1, targeting B2B merchants.
Role: Senior Prestashop Expert adhering to PSR-12 standards and the CMS’s Symfony structure.
Task: First propose the list of required hooks (e.g., actionCartSave) and the file tree before generating any code.

Analysis: By forcing the AI to validate the technical structure and hooks before implementation, we prevent it from generating obsolete monolithic code. The Senior Expert role ensures the use of namespaces and modern service containers instead of legacy static classes.

4. Practical Case 2: Laravel Architecture and Logic

In modern frameworks, AI excels at structuring business logic—if guided on architectural patterns.

CRT Application

Prompt:

Context: Payment microservice in a Laravel 11 application following hexagonal architecture principles.
Role: Software Architect specializing in Clean Code.
Task: Sketch the interface contract and PaymentService class structure with dependency injection. Ask me 3 clarification questions about payment gateways (Stripe/Adyen) before proceeding.

Justification: Here, the Task prioritizes design. Requesting an "interface contract" enforces decoupling rigor that the AI would overlook in a fuzzy prompt. This prevents spaghetti code and reduces technical debt from the outset.

5. Practical Case 3: Brainstorming a New Feature

AI isn’t just an executor—it’s a co-creation partner. Using CRT in brainstorming turns the tool into a strategic consultant.

CRT Application

Prompt:

Context: Gamification feature for a B2B productivity SaaS. Goal: Increase monthly retention.
Role: Product Designer specializing in engagement psychology (Gamification).
Task: Don’t propose solutions yet. Ask me 5 critical questions to identify my technical constraints and the user behaviors I want to encourage.

The Collaborative Approach: This method flips the burden of proof. Instead of expecting a perfect answer on the first try, we use AI to spotlight the project’s blind spots, refining the initial intent before production.

6. The Collaborative Approach: Using AI to Refine the Prompt

Shifting from a "command prompt" to a "conversational prompt" is the real paradigm shift. The first prompt should often just initiate a clarification phase.

Collaborative Optimization Strategies

Mirror Prompt: "Here’s my technical intent [Intent]. Identify the fuzzy areas you’d have to guess to respond, and ask me questions."
Triangulation: "Propose a simple, precise, and advanced version of this prompt for my needs."
Self-Improvement: "Act as a Prompt Engineering expert. Rephrase my initial request to maximize generated code quality per SOLID standards."

Beyond the Prompt: Context Engineering
If Prompt Engineering structures the request, final quality also depends on the data provided. The "next level" is Context Engineering: feeding the AI your own documentation, config files, or style guides so it stops guessing and reasons within your actual environment.

7. Practical Tool: Universal CRT Prompt Template

Use this template to standardize exchanges and automate clarity in your daily workflow.

# CONTEXT
[Project, tech stack, version, target audience, overall goal]

# ROLE
[Expert/Architect/Educator – Defines standards and tone]

# TASK
[Precise action. Request structure/questions before the final output]

# CONSTRAINTS & FORMAT
[Output format (JSON, Markdown, Code), what to avoid, PSR standards, etc.]

Golden Rules for Execution:

Precision beats length: Don’t write a novel—clarify friction points.
Humans are sovereign: AI proposes and rephrases; the developer validates and directs. Human validation remains the only safeguard against business logic errors.
Iterate systematically: The best prompt is rarely the first; it’s the product of mutual clarification.

AI performance isn’t about "magic"—it’s a direct reflection of your instructions’ intelligence. By structuring requests with the CRT method, you stop enduring the machine’s guesswork and start piloting a robust, predictable work assistant.

AI is a Super-Fuel, Don't Let It Turn Into a "Slop" Factory

Nicolas Dabene — Sat, 06 Jun 2026 09:45:03 +0000

People talk about Artificial Intelligence all day long. For some, it’s a magical revolution; for others, an invisible threat. In reality, AI is neither: it’s an amplifier.

When used wisely, it boosts our creativity and productivity. Left to its own devices, without human oversight, it generates a new kind of nuisance that is starting to flood our daily lives: "AI Slop" (or digital sludge).

Here is why it’s urgent to understand this phenomenon and learn how to protect ourselves from it.

1. AI as a Co-pilot: The Bright Side

Before talking about what goes wrong, let's remember an essential truth: generative AI (like ChatGPT) is a fantastic tool. It doesn't replace humans; it’s an idea accelerator.

Got writer's block? It can give you an outline in three seconds.
Need a sounding board? It helps structure your arguments, find counter-arguments, or simplify a complex concept.
Writing issues? It polishes the tone of an important email.

In these cases, humans remain in control: you bring the expertise, the direction, and the critical thinking. AI is just the pen.

2. "AI Slop": When the Machine Runs on Empty

The problem arises when humans are removed from the equation. That’s where Slop comes from.

Definition: AI Slop is any text, visual, or audio content generated in bulk by AI and dumped onto the web without any verification, review, or added value.

It’s the fast food of information. We find it in several forms:

Endless blog posts that beat around the bush just to please Google's search algorithms.
Weird images on social networks (like those bizarre AI-generated photos of children or strange structures) designed solely to trick unsuspecting users into clicking.
Error-ridden practical guides sold on Amazon, written in three clicks by robots.

The goal of Slop is never to inform, educate, or entertain. Its sole purpose is to take up visual space to generate ad revenue from your clicks.

3. Why Is This Dangerous?

If it were just poor-quality content, it would only be an aesthetic issue. But Slop poses three major risks for all of us:

Information drowning: It’s becoming increasingly harder to find reliable, human-verified information in an ocean of text generated by the mile.
Trust pollution: By constantly encountering empty or false content, users end up doubting everything, even legitimate sources.
Lack of substance: An AI doesn’t "think." It predicts logical words one after another. Without control, it can state absurdities with perfect confidence (what we call hallucinations).

4. Survival Guide: How to Spot Slop

To avoid getting fooled, develop a few simple reflexes:

The "lukewarm water" style: Does the text use grandiose but empty phrases? (e.g., "In the ever-evolving landscape of...", "It is crucial to understand that..."). If the text is polite, long, but takes no stance and provides no concrete anecdotes, be suspicious.
Lack of a real source or author: Who wrote this article? Is it a real researcher, a journalist, an expert with a track record, or an anonymous profile created three days ago?
Absurd visual details: For images, look closely at the hands (often six fingers or strange shapes), blurry or illogical backgrounds, and textures that are too smooth, almost "plastic-like."

In Conclusion: Demand Substance, Stay Human

Artificial Intelligence is a historic opportunity to free ourselves from repetitive tasks and stimulate our intellect. But just like with food, we must become demanding consumers. Reject textual sludge; look for critical thinking, nuance, and the human touch. This is the only way to ensure that AI remains at our service, not the other way around.

AI at the Crossroads: Between the Profitability Mirage and the Reality of Efficiency

Nicolas Dabene — Thu, 04 Jun 2026 22:15:03 +0000

Generative artificial intelligence is undergoing a brutal transition phase. The euphoria of early deployments is giving way to an uncompromising demand for financial return. As a FinOps strategist, my observation is clear: AI is not a magic solution; it is a power infrastructure. Without rigorous resource management and a dedicated architecture, it risks becoming the greatest value destroyer of the decade. The time for experimentation is over; the focus is now on the industrial mastery of ROI.

1. The Profitability Paradox: From "Capex" to the Wall of Realities

The enthusiasm for generative AI is colliding today with a fundamental question posed by Jim Covello (Goldman Sachs): "What $1 trillion problem does AI actually solve?". The gap between massive investments and actual revenues is abyssal. According to Sequoia Capital, the industry must generate $600 billion per year to justify current infrastructure expenditures (Capex). However, the market leader OpenAI peaks at $3.4 billion in revenue. By comparison, Microsoft alone forecasts $190 billion in Capex for calendar year 2026 to expand its computing capabilities.

We are reliving the railway analogy: a phase of massive over-investment necessary to build a foundational infrastructure, where only the players capable of mastering their operational costs will survive the bursting of the bubble.

This discrepancy illustrates the "Solow Paradox," updated by McKinsey: AI is everywhere except in productivity statistics. Two factors explain this lag:

The "J-Curve" of adoption: As indicated by Governor Michael Barr (Fed), initial adjustment costs lead to short-term losses before real gains materialize.
Competitive erosion: Horizontal productivity (simple chatbot usage) does not create a sustainable advantage. It becomes "table stakes," with the gains captured by the end consumer rather than by the company's margins.

Transition: This lack of profitability is not a technological fatality, but the symptom of unmanaged resource consumption.

2. The Token as a Natural Resource: Toward an Ethic of Consumption

We must stop viewing the "Token" as an IT abstraction. Every token is the physical product of massive energy and freshwater consumption. AI's ecological footprint is now an operational reality: pollution in rural communities adjacent to data centers and skyrocketing electricity bills.

From a FinOps perspective, algorithmic inefficiency must be treated as industrial waste. A prompt of 1,000 tokens where 50 would suffice is not a mistake; it is a waste of financial and natural capital. Every unnecessarily verbose interaction reduces your margins and degrades your carbon footprint. The sustainability of businesses will depend on their ability to establish consumption discipline: every generated token must have clear attribution and demonstrable business value.

Transition: The solution to this waste lies in education: Prompt Engineering must become an organizational survival skill.

3. The Professionalization of AI: Prompt Engineering for All

Prompt Engineering training is not a luxury for developers; it is the bedrock of operational efficiency. The lack of expertise is the primary failure factor in AI projects. Data from FullStack and Gartner leave no room for doubt:

85% of AI projects fail due to poor data quality or a lack of skills.
A 50% talent gap paralyzes the deployment of solutions.

Without training, AI remains a "gadget" whose logical errors prove costly. Prompt Engineering allows a transition from generalist AI (Horizontal AI)—which dilutes value—to precision AI (Vertical AI). A trained employee knows how to reduce informational "noise," thereby limiting token consumption while increasing the relevance of the output. This is where waste reduction occurs: moving from a trial-and-error approach to response engineering.

Transition: However, human skill must be backed by a software architecture designed for yield.

4. The Architecture of Efficiency: Specialized Agents and FinOps

To maximize ROI, we must abandon the "one model for everything" paradigm. Using a Frontier model (such as GPT-4o or Claude Opus) for a simple classification task is an economic aberration. The winning strategy relies on Model Tiering and technical optimization.

Using tools like vLLM, throughput can be multiplied by 3 to 6 times, while prompt compression via LLMLingua reduces input size by a factor of 20 with minimal performance loss. Implementing semantic caching (Alice Labs) completely eliminates inference costs for recurring queries, reducing API expenditures by up to 80%.

Dimension	Uncontrolled AI (Shadow AI)	Architected AI (FinOps)
Cost Model	Explosive and unpredictable API costs	Mastered Unit Economics
Model Selection	Systematic use of Frontier models	Model Tiering (Nano vs Frontier)
Token Cost (1M)	~$15.00 (Frontier)	$0.10 (Nano/Small)
Governance	No visibility	Tagging, Attribution & Showback
Efficiency	Redundant inferences	Semantic caching
Latency	High (heavy models)	Optimized via compression & cache

This approach transforms AI from a speculative cost center into a sustainable infrastructure capable of absorbing scale without a linear correlation in costs.

5. Conclusion: Defining a Framework for Reasoned AI

The success of AI will not be measured by the volume of your investments, but by the precision of your management. A successful adoption rests on three non-negotiable pillars:

FinOps Governance: Implement a systematic tagging and attribution system for every API call to enable chargeback/showback between departments.
Mass Training: Elevate the skill level in Prompt Engineering to transform every employee into a digital resource manager.
Specialized Architecture: Deploy micro-agents and small models (Small Parameter Models) for vertical tasks, reserving expensive models for complex problems.

AI is no longer a bubble to be contemplated, but a resource to be administered. Shift from being a passive consumer suffering from bills to a responsible driver of your digital efficiency.

`/grill-me`: The Command That Stops AI Agents From Coding the Wrong Thing

Nicolas Dabene — Fri, 29 May 2026 05:22:18 +0000

TL;DR

Most AI agent failures don’t come from bad code.
They come from bad assumptions.

In Antigravity, the /grill-me command forces the agent to stop executing… and start thinking.

Instead of generating code immediately, the agent:

asks questions,
clarifies requirements,
identifies blind spots,
challenges technical decisions,
validates the architecture before writing a single line of code.

And honestly?

It’s probably one of the best habits you can adopt when working with AI agents.

🤖 The Real Problem With AI Agents

Modern AI agents are impressive.

You tell them:

“Build me a PrestaShop module with API synchronization and an admin dashboard.”

And they immediately start building.

The problem:
they often start moving… in their own direction.

Why?

Because an AI agent:

fills in the blanks,
interprets intent,
assumes constraints,
invents business behaviors.

The result:
you sometimes end up with:

the wrong architecture,
incorrect business assumptions,
an unwanted tech stack,
unmaintainable technical decisions,
or simply… something that doesn’t match your real need.

The worst part?

The code can still be technically good.

But completely off target.

🔥 `/grill-me` Completely Changes the Dynamic

The /grill-me command changes how the agent behaves.

Instead of:

“I’ll start coding immediately.”

The agent switches to:

“First, I need to fully understand what you want.”

It becomes a technical interrogation.

The agent starts to:

ask targeted questions,
request examples,
clarify edge cases,
verify constraints,
identify ambiguities,
validate priorities,
anticipate architectural problems.

And that changes everything.

🧠 Why This Approach Is Extremely Powerful

1. It Reduces Business Hallucinations

AI agents rarely hallucinate syntax.

They mostly hallucinate:

intent,
requirements,
workflows,
implicit business rules.

/grill-me drastically reduces this problem.

2. It Forces Requirement Clarification

Most projects start with vague specifications.

And very often:
even the human developer hasn’t fully clarified the need yet.

/grill-me then acts like:

an architect,
a Product Owner,
a tech lead,
a functional challenger.

The agent becomes a requirement refinement tool.

3. It Prevents Bad Starts

A bad AI-driven start is expensive:

refactoring,
rewrites,
context loss,
technical debt,
fragile architecture.

A few minutes of intelligent questioning can save hours of corrections later.

⚙️ A Concrete Example

You ask:

“Build me an ERP synchronization system for PrestaShop.”

Without /grill-me, the agent could:

choose the wrong sync strategy,
assume real-time flows,
ignore scalability constraints,
create a non-scalable architecture,
forget retries,
ignore data conflicts.

With /grill-me, the agent could ask:

What is the source of truth?
Is synchronization bidirectional?
What is the product volume?
Real-time or batch processing?
Conflict resolution strategy?
Expected SLA?
Multi-store support?
Target PrestaShop compatibility?
REST or SOAP API?
Retry management?
Queue system?
Is idempotency required?
Failure tolerance expectations?

And suddenly:
we’re no longer just talking about “generating code”.

We’re talking about:
designing a system correctly.

🚀 Other Essential Commands in Antigravity

`/goal`

/goal is basically the opposite of /grill-me.

Here:
the agent receives a final objective and operates autonomously until the task is complete.

Example:

/goal Fix all broken tests and stabilize the CI pipeline

The agent:

plans,
executes,
fixes,
iterates,
validates.

Without asking for intermediate approvals.

This is extremely powerful for:

refactoring,
CI/CD fixes,
migrations,
repetitive tasks,
well-scoped workflows.

`/schedule`

This command allows background task scheduling.

Typical use cases:

scheduled jobs,
delayed execution,
recurring automations,
AI cron jobs.

Example:

/schedule Analyze logs every night at 2 AM

Very useful for:

monitoring,
automated QA,
audits,
technical watch,
proactive maintenance.

`/browser`

This command explicitly forces the use of the web browsing sub-agent.

The agent can then:

navigate websites,
interact with pages,
test interfaces,
perform research,
inspect rendering.

Example:

/browser Test the mobile checkout flow

Very useful for:

frontend QA,
scraping,
UI debugging,
SEO verification,
automated user testing.

🏗️ The Real Shift: From Prompting to Orchestration

Developers who perform best with AI agents are no longer just people who “write good prompts.”

They are people who know how to:

orchestrate,
frame problems,
break down tasks,
supervise,
validate assumptions,
control context.

/grill-me is interesting because it formalizes this mindset.

The developer does not become less important.

Quite the opposite.

Their role evolves toward:

arbitration,
clarification,
architecture,
strategic supervision.

The agent executes.
The human pilots.

✅ When To Use `/grill-me`

Use it systematically for:

complex architectures,
e-commerce modules,
business workflows,
API integrations,
multi-service systems,
migrations,
AI projects,
automation pipelines,
anything where bad assumptions are expensive.

❌ When Not To Use `/grill-me`

It’s unnecessary for:

a tiny isolated function,
a trivial bug fix,
a highly constrained task,
a simple mechanical operation.

In those situations:
/goal will usually be faster.

🎯 Conclusion

The biggest risk with AI agents is not that they code poorly.

It’s that they code fast…
in the wrong direction.

/grill-me acts like an intelligent safeguard:

it intentionally slows down the beginning,
to massively accelerate everything afterward.

And the more autonomous agents become,
the more critical this clarification phase becomes.

Because in the end:

A very fast AI agent with bad assumptions is still… an error accelerator.

— Nicolas Dabène

PHP 8.6 introduces `clamp()` : a small function that greatly improves code readability

Nicolas Dabene — Thu, 28 May 2026 23:30:04 +0000

PHP 8.6 introduces a very simple new native function… but one that is extremely useful in day-to-day development:

clamp()

Its purpose is straightforward:

Keep a value within a defined minimum and maximum range.

In other words:

if the value is too low → return the minimum
if the value is too high → return the maximum
otherwise → return the value itself

It sounds simple.

But in practice, it significantly improves:

readability
business intent clarity
maintainability
bug reduction

Documentation:
https://php.watch/versions/8.6/clamp

PHP 8.6 release timeline

The current planned GA (General Availability) release date for PHP 8.6 is:

November 19, 2026

Official schedule:

Alpha 1: July 2, 2026
Feature Freeze + Beta 1: August 13, 2026
GA (General Availability): November 19, 2026

As always with PHP:

the schedule may still change
features may evolve before final release

The problem before PHP 8.6

Until now, most PHP developers wrote code like this:

$value = max($min, min($max, $value));

Example:

$score = max(0, min(100, $score));

This works perfectly.

But:

it is not intuitive to read
you must mentally parse max(min())
the business intent is not explicit
beginners often get confused by parameter order

Another very common pattern:

if ($score < 0) {
    $score = 0;
}

if ($score > 100) {
    $score = 100;
}

This is correct, but verbose and noisy for such a simple rule.

The new syntax

With PHP 8.6:

clamp($value, $min, $max);

Example:

$score = clamp($score, 0, 100);

Immediately:

intent becomes obvious
code becomes self-documenting
business logic is clearer

How `clamp()` works

Case 1 — value already within range

echo clamp(50, 0, 100);

Result:

The value is already valid.

Case 2 — value too small

echo clamp(-20, 0, 100);

Result:

The value is clamped to the minimum.

Case 3 — value too large

echo clamp(250, 0, 100);

Result:

The value is limited to the maximum.

Mental model

          clamp(value, min, max)

                ▼
        ┌─────────────────┐
        │ value < min ?   │──► return min
        └─────────────────┘

                ▼
        ┌─────────────────┐
        │ value > max ?   │──► return max
        └─────────────────┘

                ▼
            return value

Real-world use cases

Progress percentage

$progress = clamp($progress, 0, 100);

Useful for:

progress bars
scoring systems
XP systems
discount percentages

Pagination safety

$page = clamp($page, 1, 999);

Prevents:

negative pages
invalid inputs
pagination bugs

CSS opacity

$opacity = clamp($opacity, 0.0, 1.0);

Amount limits

$amount = clamp($amount, 10, 5000);

Common in:

payments
transfers
API quotas
rate limiting systems

Game stats

$health = clamp($health, 0, 100);
$mana = clamp($mana, 0, 200);

`clamp()` supports integers and floats

Integers

clamp(15, 0, 10);

Result:

Floats

clamp(3.14, 0.0, 10.0);

Result:

3.14

Float exceeding range

clamp(15.7, 0.0, 10.0);

Result:

10.0

Important rule: `$min` must be ≤ `$max`

This is invalid:

clamp(10, 100, 0);

PHP will throw:

ValueError

Because:

the minimum cannot be greater than the maximum

Official signature

function clamp(mixed $value, mixed $min, mixed $max): mixed

This means it accepts multiple types.

However…

Practical recommendation: prefer `int` and `float`

Although PHP allows:

clamp("50", 0, 100);

Or even:

clamp(true, false, false);

Mixing:

booleans
strings
loosely typed comparisons

…can lead to confusing behavior in real-world codebases.

Best practice:

use integers
use floats
avoid mixed-type comparisons

Before vs After

Before PHP 8.6

final class DiscountCalculator
{
    public function normalize(int $discount): int
    {
        return max(0, min(100, $discount));
    }
}

With PHP 8.6

final class DiscountCalculator
{
    public function normalize(int $discount): int
    {
        return clamp($discount, 0, 100);
    }
}

The improvement in readability is immediate.

Polyfill for PHP < 8.6

If you want to use clamp() today:

if (!function_exists('clamp')) {
    function clamp(mixed $value, mixed $min, mixed $max): mixed
    {
        if ($min > $max) {
            throw new ValueError(
                'clamp(): Argument #2 ($min) must be less than or equal to argument #3 ($max)'
            );
        }

        if ($value < $min) {
            return $min;
        }

        if ($value > $max) {
            return $max;
        }

        return $value;
    }
}

This replicates the expected behavior of PHP 8.6.

Why this small feature matters

This is not a revolutionary language change.

But it meaningfully improves:

code clarity
intent expression
developer experience
long-term maintainability

It is exactly the kind of function that is:

simple
universal
immediately useful

Comparison with other languages

clamp() already exists in many modern ecosystems:

C++
Rust
Kotlin
Swift
C#
JavaScript (via helpers)
Python (via libraries)

PHP is finally aligning with this common pattern.

Conclusion

clamp() is one of those small additions that quickly becomes everywhere in your codebase.

Before:

$value = max($min, min($max, $value));

After:

$value = clamp($value, $min, $max);

More readable.
More explicit.
Less error-prone.
Better intent.

And honestly…
once you start using it, going back feels unnecessarily complex.

Nicolas Dabène

Developer at https://versus.pro

Anthropic Launches Claude Security: The AI That Detects Vulnerabilities in Your Code

Nicolas Dabene — Thu, 28 May 2026 23:30:02 +0000

Anthropic has just crossed a major milestone in AI-assisted software security. Claude Security, the code analysis tool the company had been developing since February under the name Claude Code Security, is now available in public beta. And honestly, this is one of the most promising evolutions I’ve seen in security code analysis in a long time.

TL;DR — If you only have 30 seconds: Claude Security scans your code, validates detected vulnerabilities, and suggests fixes. Public beta is available now for Enterprise customers.

How Claude Security Works

In practice, the tool goes far beyond simply scanning your codebase for known patterns. Claude Security tracks data flows across files, reads Git history to understand context, and understands the business logic behind the code. Where traditional tools stop at pattern matching, this is real semantic analysis.

Every detected vulnerability comes with:

A confidence score for the diagnosis
A severity assessment
The likely impact on the system
The steps required to reproduce the issue
A suggested fix directly openable in Claude Code on the Web

And most importantly — a critical point — every fix requires human review and approval before being applied. Teams stay in control. Personally, I think this is exactly what we should expect from a tool operating in the security space: no automatic application, no unexpected production changes.

New Features Included in the Public Beta

Feature	What It Enables
Scheduled scans	Automate security checks at regular intervals
Directory targeting	Restrict scans to a specific project path
Documented dismissal	Keep a record of triage decisions for future teams
CSV/Markdown export	Integrate results into existing audit systems
Webhooks	Send alerts to Slack, Jira, and other third-party tools

These features address real-world needs I regularly hear from development teams: automating security without losing traceability, while integrating smoothly into existing workflows.

Claude Security Availability

The tool is available immediately in public beta for Claude Enterprise customers, via the Claude.ai sidebar or directly at claude.ai/security. Administrators can enable it from the admin console.

Important point: no API integration or custom agent development is required. This is plug-and-play for Enterprise customers.

Access for Team and Max plans is expected soon — I’d recommend keeping an eye on future announcements if you’re not yet on Enterprise.

Behind Claude Security: A Broader Cybersecurity Strategy

It would be incomplete to discuss Claude Security without mentioning the larger context. This launch is part of a broader offensive cybersecurity strategy from Anthropic, initiated a few weeks ago with Claude Mythos Preview.

For context, Mythos Preview is considered too powerful to be released publicly — it is accessible only to around fifty partner organizations responsible for securing critical infrastructure. Meanwhile, Claude Security relies on Claude Opus 4.7, Anthropic’s latest public-facing model, which includes cybersecurity safeguards derived from Project Glasswing.

Beyond security itself, this move also allows Anthropic to push Opus 4.7 deeper into its partner ecosystem: CrowdStrike, Microsoft Security, Palo Alto Networks, and others. It’s a smart strategy — and it shows the company is not only playing the technical card, but also the ecosystem card.

🔑 Key Takeaways

Claude Security is now in public beta for Enterprise customers — Team and Max plans will follow.
The tool goes beyond pattern recognition by understanding business logic and tracking data flows.
Every suggested fix requires human approval — no automatic application, which is the responsible approach.
New features such as scheduled scans, webhooks, and exports directly address professional team requirements.
This launch fits into a broader strategy positioning Opus 4.7 as Anthropic’s flagship cybersecurity model.

Conclusion

To put it simply: Claude Security looks like what code security should always have been — an assistant that truly understands what it scans, not just a pattern detector. Does it replace human security audits? No. Does it make code review faster and more comprehensive? Absolutely.

Personally, I’ll be watching this very closely. If you’re on an Enterprise plan and running production code, enabling Claude Security should be an obvious move.

Nicolas Dabène — Developer of the MCP Tools Plus module for PrestaShop & expert in e-commerce security architecture.

The Era of Orchestration: Why 2026 Marks the End of Code as We Know It

Nicolas Dabene — Thu, 28 May 2026 23:15:03 +0000

In February 2026, Andrej Karpathy triggered what the industry now calls the Breakpoint of software engineering. His assessment is unequivocal: the programming profession is undergoing radical « refactoring ». For the modern developer, the feeling of experiencing a « Skill Issue » has become chronic—not due to lack of talent, but because tools evolve faster than our mental frameworks. We must face the truth: code is no longer the output; it’s the residue. The challenge is no longer writing syntax, but mastering Agentic Engineering.

1. The Shipwreck of Pure Autonomy: The Devin Case

2025 buried the myth of the totally autonomous agent. The Devin case became a cautionary symbol of the costly « black box ». Despite the promises, real-world success rates on complex tasks (measured by SWE-bench) stagnated between 13.8% and 15%.

The massive rejection of Devin by engineering teams in 2026 stems not merely from technical failures, but from an architectural control deficit and unacceptable economic opacity. At $500/month per seat plus $2 per ACU (Agent Compute Unit), companies realized that blindly delegating to an AI that « charges ahead » without alerting human supervisors was financial suicide. The market is shifting toward structured control models like Intent, where developers validate each planning step.

💡 The insight — The problem isn’t the agent’s intelligence, but the absence of a control harness.

2. The « Harness » Outperforms the Model: Amazon Kiro’s Approach

A system’s intelligence no longer resides in the LLM’s raw power, but in its support infrastructure: the Harness. A mediocre model with rigorous execution harness will always outperform the largest model left to its own devices.

This agentic stack rests on four critical layers:

Context: Semantic indexing (RAG) of hundreds of thousands of files.
Planning: Decomposing intent into logical sub-tasks.
Execution: Interacting with the world via MCP (Model Context Protocol) and Agent Hooks (automatic triggers on file events).
Learning: Persistent memory that prevents error repetition.

The prime example of this rigor is Amazon Kiro. Unlike intuitive coding, Kiro enforces a « Spec-driven » flow: transforming prompts into structured requirements using EARS format (When X, the system shall Y), followed by visual design via Mermaid, before any line of code.

Sources : Andrej Karpathy - Breakpoint, Amazon Kiro, SWE-bench

3. The Toxicity of « Vibe Coding »: The 90-Day Wall

Vibe Coding — the practice of coding « by feel » through prompt iterations without architectural vision — delivers misleading initial euphoria. It’s a high-velocity drug that masks explosive technical debt. A major study on 8.1 million pull requests confirms that ungoverned AI adoption increases technical debt from 30% to 41%.

The cycle is ruthless:

Phase Symptom Day 1 Development speed multiplied by ten Day 30 Duplicated logic appears, coherent error handling disappears Day 90 The wall. Code becomes « hostile ». Modifying a minor function triggers bug cascades no one can resolve Dimension Vibe Coding (Initial) Long-Term Maintenance Structured Control (Intent/Kiro) Input Vague natural language Deep understanding Structured specifications (EARS) Quality « Happy path » only Systemic fragility Edge case coverage Control Speed illusion Refactoring wall Human validation at each step > ⚠️ The warning — Vibe Coding kills maintainability. It’s the fastest route to the Technical Debt Ramp.

4. Micro-societies of agents: The MiroFish Explosion

Innovation no longer requires armies of engineers. In just ten days, a student at China’s University of Posts and Telecommunications, Guo Hangjiang, built MiroFish. With $4 million in funding from Chen Tianqiao (30 million yuan), this project illustrates the radical democratization of technological power.

MiroFish uses the OASIS framework to create not a chatbot, but a massive social simulation. By creating thousands of agent personas with persistent memories (via Zep Cloud), the system produced a credible ending to the literary masterpiece Dream of the Red Chamber. This shift from « answering a question » to « problem-solving via simulation » marks the future of public opinion prediction and market analysis.

💡 What changes — We move from the « I ask a question » paradigm to the « I run a simulation » paradigm.

5. Don’t Build a Mega-Agent, Orchestrate a Team

The fatal mistake in 2026 is trying to create an omniscient agent. Context saturation inevitably leads to hallucination. Software survival depends on collaborative architecture patterns:

Parallel Pattern (Swarms)

Ideal for massive research and divergent data analysis. Multiple agents simultaneously explore different branches of a problem.

Sequential Pattern (Pipeline)

For rigorous production. Each step validates the previous before moving to the next: Research → Writing → QA.

Supervisor Pattern

The core of ASD (Agentic Software Development). A coordinator agent decomposes tasks, delegates to specialists, and handles error recovery. This supervisor transforms stochastic chaos into reliable engineering.

💡 The key point — The Mega-Agent is a myth. Orchestration is the reality.

Conclusion: Toward « Software for One »

The developer’s role has shifted. You no longer write code—you orchestrate intent. We’re entering the era of Software for One: the ability to generate unique applications, throwaway or permanent, meeting an instant need.

Code has become a commodity; intent architecture is your new added value. If you could orchestrate a team of 1000 agents to solve a complex problem tomorrow, what would be the first step in your specification? The answer to this question defines your future in this new era.

The question to ask — Are you a developer who writes code, or an architect who orchestrates intent?

Nicolas Dabène — Architect of AI-native e-commerce transition & developer of MCP Tools Plus for PrestaShop. Certified PrestaShop expert with over 15 years of experience.

DEV Community: Nicolas Dabene

5 Claude Code Features That Many Developers Underutilize

🧠 The Problem Is Almost Never the Model

📄 CLAUDE.md: The File That Avoids Repeating the Same Things

🔒 Hooks: When Rules Become Automatic

🤔 Ultrathink: A Resource to Use Sparingly

🧹 /compact: The Feature Many Discover Too Late

👥 Subagents: The Feature That Scales

🚀 The Real Productivity Multiplier

Why You Should Almost Never Send a PDF, DOCX, or Image to ChatGPT or Claude

TL;DR

🚨 The Hidden Token Tax

📄 Why PDFs Are Particularly Inefficient

📝 DOCX Files Aren't Much Better

🖼️ Images Are Often the Worst Case Scenario

📊 Not All Formats Are Equal

💰 The False Debate: Changing Models

🚀 A Smarter Approach: Preparing Documents for LLMs

🎯 The Real AI Challenge in 2026

E-commerce Compliance: Why Some PrestaShop Modules Become Essential Building Blocks

Introduction: E-commerce Enters a New Phase

When Compliance Becomes a Development Issue

The Invisible Work Behind a PrestaShop Module

MedRetractation: An Example of a Problem-Focused Module

PrestaShop’s Strength Also Lies in Its Editors

Conclusion: Value Often Lies in the Problems No One Wants to Handle

Contrib.: When Media Must Evolve with Communities

Introduction

From Audience to Community

Technology Advances, but Understanding Remains Essential

Building the Reflection Spaces of the Future

Conclusion

The Sovereignty of E-Commerce: Why Open Source Could Be Tomorrow’s True Answer

Introduction: After AI Sovereignty, E-Commerce Sovereignty

A Question I Receive Regularly: Is PrestaShop Still Viable?

The Acquisition of PrestaShop: A Transition to View Differently

Open Source as a Strategic Answer

The PSE: A Negative Signal or a Difficult Choice in a Time of Acceleration?

The Interesting Signal: PrestaShop Begins to Look at the AI Era

Will the Future of E-Commerce Be Open?

PrestaShop #OpenSource #Ecommerce #AI #DigitalSovereignty

The CRT Method for Developers: Mastering the Art of Prompt Engineering

1. Introduction: Moving Beyond the "Fuzzy Prompt" in Development

2. Anatomy of the CRT Method: Context, Role, Task

Breakdown of the Three Pillars

Summary: Fuzzy Prompt vs. CRT Prompt

3. Practical Case 1: Developing a Prestashop Module

CRT Application

4. Practical Case 2: Laravel Architecture and Logic

CRT Application

5. Practical Case 3: Brainstorming a New Feature

CRT Application

6. The Collaborative Approach: Using AI to Refine the Prompt

Collaborative Optimization Strategies

7. Practical Tool: Universal CRT Prompt Template

Golden Rules for Execution:

AI is a Super-Fuel, Don't Let It Turn Into a "Slop" Factory

1. AI as a Co-pilot: The Bright Side

2. "AI Slop": When the Machine Runs on Empty

3. Why Is This Dangerous?

4. Survival Guide: How to Spot Slop

In Conclusion: Demand Substance, Stay Human

AI at the Crossroads: Between the Profitability Mirage and the Reality of Efficiency

1. The Profitability Paradox: From "Capex" to the Wall of Realities

2. The Token as a Natural Resource: Toward an Ethic of Consumption

3. The Professionalization of AI: Prompt Engineering for All

4. The Architecture of Efficiency: Specialized Agents and FinOps

5. Conclusion: Defining a Framework for Reasoned AI

`/grill-me`: The Command That Stops AI Agents From Coding the Wrong Thing

TL;DR

🤖 The Real Problem With AI Agents

🔥 /grill-me Completely Changes the Dynamic

🧠 Why This Approach Is Extremely Powerful

1. It Reduces Business Hallucinations

2. It Forces Requirement Clarification

3. It Prevents Bad Starts

⚙️ A Concrete Example

🚀 Other Essential Commands in Antigravity

/goal

/schedule

🔥 `/grill-me` Completely Changes the Dynamic

`/goal`

`/schedule`

`/browser`

✅ When To Use `/grill-me`

❌ When Not To Use `/grill-me`

How `clamp()` works

`clamp()` supports integers and floats

Important rule: `$min` must be ≤ `$max`

Practical recommendation: prefer `int` and `float`