DEV Community: david duymelinck

Creating a Symfony Tui application

david duymelinck — Mon, 06 Apr 2026 06:28:33 +0000

After my first post about Symfony Tui, I really wanted to kick the tires of the component.

The idea

Non technical people don't like it when applications give them too much rules. And one of the biggest offenders for me are markdown driven applications.
So I wanted to make an application where they can add a directory where the markdown files are stored.

For the interface there are two parts, the filesystem part and the editor part.
The filesystem part has a filetree and an option to add new files. A sub function of the filetree is the possibility to delete a file.
The editor part has two tabs; markdown and frontmatter. It is possible to switch between them. And by pressing return the content of both editors is saved to the selected file in the filetree.

The good

The command does not have a lot of content, because I could extract the TUI code to a separate class.

Working with containers feels like divitis, but I would have never suspected that it would one day feel like a good thing.

$markdownTab = new TextWidget('Markdown');
$markdownTab->setId(self::MARKDOWN_TAB_ID);
$markdownTab->addStyleClass('bold');
$frontmatterTab = new TextWidget('Frontmatter')->setId(self::FRONTMATTER_TAB_ID);

$tabs = new ContainerWidget();
$tabs->setStyleClasses(['flex-row', 'gap-1']);
$tabs->setId(self::CONTENT_TABS_ID);
$tabs->add($markdownTab);
$tabs->add($frontmatterTab);

$markdownEditor = new EditorWidget()->setId(self::MARKDOWN_EDITOR_ID);
$markdownEditor->onSubmit($this->saveEditorsToFile(...));
$frontmatterEditor = new EditorWidget()->setId(self::FRONTMATTER_EDITOR_ID);
$frontmatterEditor->setStyleClasses(['hidden']);
$frontmatterEditor->onSubmit($this->saveEditorsToFile(...));

$editors = new ContainerWidget();
$editors->setId(self::CONTENT_EDITORS_ID);
$editors->add($markdownEditor);
$editors->add($frontmatterEditor);

$content = new ContainerWidget();
$content->setId(self::CONTENT_ID);
$content->setStyleClasses(['flex-col', 'gap-1']);
$content->add($tabs);
$content->add($editors);

This is my poor mans attempt of a tabs widget, which is coming in a future Tui component PR.

The style classes are working because the Tui component comes with a TailwindStylesheet. To use the class you can add it to the Tui constructor as an argument or use the addStyleSheet method.
As I mentioned in my previous post if you like the class extend it and add your own rules, to have the best of both worlds.

Having the option to set ids for each widget is great. As you can see in the example I'm using class constants to keep them organized.

The on method and the more specified onX methods make it easy to add widget and TUI behavior.

The bad

Because the TUI runs in an eventloop some of the actions are going to require the need to dispatch them in order to see the change instantly.
As far as I figured it out all the methods from the widgets that can dispatch are private.

In my case I wanted to update the filetree as soon as a new file is submitted or when a file got deleted.

$newFile = new InputWidget();
$newFile->setId(self::NEW_FILE_ID);
$newFile->setPrompt('New File (can contain path): ');
$newFile->onSubmit(function(SubmitEvent $event) {
    if($event->isEmpty()) {
        return;
    }

    $input = $event->getValue();

    if(!str_ends_with($input, '.md')) {
       $input .=  '.md';
    }

    touch($this->source . '/' . $input);

    $event->getTarget()->setValue('');

    $sourceFiles = $this->tui->getById(self::SOURCE_FILES_ID);
    $sourceFiles->onFileAction();
    $this->tui->handleInput(self::NAV_SOURCE_FILES);
});

I needed to create a child class of SelectListWidget to add the onFileAction method.

public function onFileAction() : void
{
    $items = $this->getSourceFiles();

    $this->myItems = $items;
    $this->myItemsCount = count($this->myItems);

    $this->setItems($items);

    $selectedItem = $this->myItems[0] ?? null;
    if (null !== $selectedItem) {
       $this->dispatch(new SelectionChangeEvent($this, $selectedItem));
    }
}

As you can see there is more going in the method than just a dispatch.
But it feels like there is an easier way to get it working.
Of course there is also the possibility I'm just doing it wrong.

The ugly

I don't think it is completely the blame of the Tui component but shortcuts are the straw that broke the camel's back for me.

I'm using PHPStorm and a WSL debian terminal to manually test my application.

I needed to add a whole slew of shortcuts as a line in the command just to remember them myself.

Shortcuts: ctrl+b -> filetree (return to display content, ctrl+i -> delete file) ; ctrl+d -> new file (return to create) ; ctrl+e -> markdown ; ctrl+r -> frontmatter (both editors return to save) ; ctrl+j -> quit.'

I wanted similar shortcuts close to each other, or in the case of ctrl+d and ctrl+b look alike.

And then I started testing the editors.

My first eyebrow raise came from using ctrl+k to focus the frontmatter editor. It did focus but it also cleared the content.
To be honest I only had a single line of frontmatter.
It wasn't until I tried ctrl+m to figure out the editor also uses the ctrl+k shortcut.

My next test was adding more lines. Now that I was aware of the editor shortcuts I found out it is shift+return. That doesn't work for me.
So I tried other keys in combination with return, and If discovered there is a combination that deletes the selected file in the filetree while the editor is the focused widget. The shortcut for deleting a file is ctrl+i, and I wasn't even close pressing i.

Conclusion

Frontend is hard with all those limitations, that is why I rather do backend work.
But it was a fun time trying to create something with a new toy.

The full code is on Github. I didn't want to make it a repository because it is just for now code.
There are many parts left undeveloped like creating files in a directory and showing the error and success messages.

While Javascript and Python based CLI tools are ruling the world, I do think with the Tui component PHP has found an answer.

Exploring the Symfony Tui component

david duymelinck — Sat, 04 Apr 2026 16:35:27 +0000

I had seen the Symfony Tui component announcement, but I just got the time to start to explore it.

Setup

To explore the component fast I checked out the PR.
Added "App\\" : "src/App" to composer.json.
Created a command, TuiTestCommand, in the App directory, and a bin/console file with a console application and the command.

In the following sections I'm going to take baby steps to understand how the component works.

Returning a text

The standard way to return a text is $output->writeln('Hello world!');

To do this with the Tui component this is:

use Symfony\Component\Tui\Tui;
use Symfony\Component\Tui\Widget\TextWidget;

// in the command
$tui = new Tui();

$tui->add(new TextWidget('Hello World!'));

$tui->onTick(fn() => $tui->stop());

$tui->run();

Because the component is meant to create rich interactive experiences it uses a bit more code to make it run.

You can look at the Tui class as an agent. You can give it rules and when called it runs those rules.
Do I have AI brain? Before AI I would probably bring up the Node event loop.

Once you call the run method, the loop starts.
So if the stop method is never called the only possibility to get out of the loop is closing the CLI.
In an actual application getting out of the loop will be less janky than in this example.

You could create a bin/MyAwesomeCodingAgent by setting the Tui code containing command as the default.

Styled text

The default way to add styling to a text is by adding faux tags.

$output->writeln('<fg=red;options=bold>Hello World!</>');

In the Tui component the way of working with CSS is mimicked. Underneath it still uses the suffix and prefix codes, but that is not our problem anymore.

use Symfony\Component\Tui\Style\Style;

// in command

$redBoldStyle = new Style()->withColor('red')->withBold();

$text = new TextWidget('Hello World!');
$text->setStyle($redBoldStyle);

This method is good for one-off cases. But when you want a bit more maintainability and consistency it is better to create a StyleSheet.

use Symfony\Component\Tui\Style\StyleSheet;

// in command

$stylesheet = new StyleSheet([
  '.red-bold' => new Style()->withColor('red')->withBold(true),
]);

$tui->addStyleSheet($stylesheet);

$text = new TextWidget('Hello World!');
$text->addStyleClass('red-bold');

For the purpose of the test I added the StyleSheet object to the command, but in an actual application I would create a SomeCommandStyleSheet or a BrandStyleSheet that contains all the possible styles. Or both, there is no reason they shouldn't be composable.

Input

The default of adding an input to a command is:

$helper = new QuestionHelper();
$question = new Question('Please enter your email: ','');
$question->setValidator(function ($answer) {
   if (trim($answer) == '') {
      throw new \RuntimeException('Email address cannot be empty');
   }
   return $answer;
});

$email = $helper->ask($input, $output, $question);

$output->writeln("Email submitted: {$email}");

Every time the user hits return without a value the question is being re-displayed together with the error text.

$tui = new Tui();

$emailInput = new InputWidget();
$emailInput->setPrompt('Please enter your email: ');
$emailInput->on(SubmitEvent::class, function (SubmitEvent $event) use ($tui, $output) {
    $email = $event->getValue();
    $statusText = $tui->getById('status-text');

    if ($event->isEmpty()) {
        $statusText->setText('Email address cannot be empty.');
    } else {
        $tui->stop();

        $output->writeln("Email submitted: {$email}");
    }
});

$tui->add($emailInput);

$statusText = new TextWidget('');
$statusText->setId('status-text');
$statusText->setStyle(new Style()->withColor('red')->withBold());

$tui->add($statusText);

$tui->run();

The thing that became clear to me when creating the input code is that the InputInterface and OutputInterface are not tied to the Tui widgets like the helper classes we got used to.

Because of the widgets is feels more like building an HTML page than working with a text interface. So I'm very exited about the upcoming PR that makes it possible to use Twig templates.

The on method brings me back to the jQuery days.
And because of the event binding the input will only take the two lines initial lines on the screen, which is better that with the helper validation.

I barely scratched the surface, but I didn't want to make the post too long. Let me know if you want to see more of the Tui component.

Agentic PHPUnit output

david duymelinck — Fri, 03 Apr 2026 06:16:07 +0000

I was made a aware of PAO. And while it think it is a good tool I think we can do better by making it more useful for an LLM.

The package has options for PHPUnit, Pest and ParaTest. I'm only going to focus on PHPUnit, version 12 in particular.

The setup

PHPUnit has an option to add extensions. The best way to let PHPUnit know your extension is in the phpunit.xml file.

<extensions>
    <bootstrap class="Tests\Extensions\AgentAwareOutputExtension"/>
</extensions>

To detect when PHPunit is run inside an agent I used the shipfastlabs/agent-detector library (I saw it in PAO). This library uses well known config variables to detect multiple agents. Because I'm trying out Mistral Vibe now I added a new script to composer.json.

"test:agent": "AI_AGENT=1 vendor/bin/phpunit"

While PAO uses json as output, I want to use markdown.
From the documentation I got that it doesn't show the errors. Which strikes me as odd because you want your coding agent to be able to fix the failing tests, not? So that is on my todo list.

The code

In the PHPUnit I saw an example where the used a intermediate class to collect the needed data, so that is what I did.

class TestDataCollector
{
    public function __construct(
        public int $failed = 0,
        public int $passed = 0,
        public int $total = 0,
        public array $messages = [],
    )
    {}

    public function write() : void
    {
        $text = '# Test results'. PHP_EOL . PHP_EOL;
        $text .= '## Summary' . PHP_EOL. PHP_EOL;
        $text .= 'failed: ' . $this->failed . PHP_EOL;
        $text .= 'passed: ' . $this->passed . PHP_EOL;
        $text .= 'total: ' . $this->total . PHP_EOL;

        if(count($this->messages) > 0) {
            $text .=  PHP_EOL . '## Failed tests' . PHP_EOL. PHP_EOL;
            $text .= '| Test | Message |' . PHP_EOL;
            $text .= '| --- | --- |' . PHP_EOL;

            foreach($this->messages as $message) {
                $text .= '| ' . $message['test'].' | ' . $message['message'] . ' |' . PHP_EOL;
            }
        }


        fwrite(STDOUT, $text);
    }
}

In the constructor I setup all the properties I needed to for PHPUnit to manipulate them based on the status of the tests.

The write method is used to display the result of the tests.
I choose to use concatenation to make it easy to maintain.

Next up is the extension, the glue that holds the different parts together.

use AgentDetector\AgentDetector;
use PHPUnit\Runner\Extension\Extension;
use PHPUnit\Runner\Extension\Facade;
use PHPUnit\Runner\Extension\ParameterCollection;
use PHPUnit\TextUI\Configuration\Configuration;
use Tests\Extensions\Subscribers\FailSubsrciber;
use Tests\Extensions\Subscribers\ErrorSubscriber;
use Tests\Extensions\Subscribers\TestsDoneSubscriber;
use Tests\Extensions\Subscribers\PassSubsrciber;

class AgentAwareOutputExtension implements Extension
{
    public function bootstrap(Configuration $configuration, Facade $facade, ParameterCollection $parameters): void
    {
        if ($configuration->noOutput()) {
            return;
        }

        $agentDetector = new AgentDetector();

        if (!$agentDetector->detect()->isAgent) {
            return;
        }

        $facade->replaceOutput();
        $facade->replaceProgressOutput();
        $facade->replaceResultOutput();

        $testDataCollector = new TestDataCollector();

        $facade->registerSubscribers(
            new PassSubsrciber($testDataCollector),
            new FailSubscriber($testDataCollector),
            new ErrorSubscriber($testDataCollector),
            new TestsDoneSubscriber($testDataCollector),
        );
    }
}

A better way would be to have the extension in its own directory, but for the purpose of the test I kept the directory structure flatter.

The Extension has a single method bootstrap, which mirrors the configuration in phpunit.xml.

PHPUnit has a --no-output CLI option that is why the first lines in bootstrap exist.

The AgentDetector lines are, as you can guess, to create a guard when an AI agent is not detected.

The replace methods are a bit unfortunately named because they prevent the display of the default output.

PHPUnit has quite a few Subscriber interfaces for all the events that can happen. So it is up to us to pick the ones we need.

use PHPUnit\Event\Test\Passed;
use PHPUnit\Event\Test\PassedSubscriber;
use Tests\Extensions\TestDataCollector;

class PassSubsrciber implements PassedSubscriber
{

    public function __construct(private TestDataCollector $testDataCollector)
    {}

    public function notify(Passed $event): void
    {
        $this->testDataCollector->passed++;
        $this->testDataCollector->total++;
    }
}

Because I don't need much data you will see most subscribers have little content.

use PHPUnit\Event\Test\Failed;
use PHPUnit\Event\Test\FailedSubscriber;
use Tests\Extensions\TestDataCollector;

class FailSubscriber implements FailedSubscriber
{

    public function __construct(private TestDataCollector $testDataCollector)
    {}

    public function notify(Failed $event): void
    {
        $this->testDataCollector->failed++;
        $this->testDataCollector->total++;

        $this->testDataCollector->messages[] = [
          'test' => $event->test()->className().'::'.$event->test()->methodName(),
          'message' => $event->throwable()->message(),
        ];
    }
}

The main difference between this subscriber and the next one is that this catches the failed tests and the next one the PHP errors.

use PHPUnit\Event\Test\Errored;
use PHPUnit\Event\Test\ErroredSubscriber;
use Tests\Extensions\TestDataCollector;

class ErrorSubscriber implements ErroredSubscriber
{

    public function __construct(private TestDataCollector $testDataCollector)
    {}

    public function notify(Errored $event): void
    {
        $this->testDataCollector->failed++;
        $this->testDataCollector->total++;

        $this->testDataCollector->messages[] = [
            'test' => $event->test()->className().'::'.$event->test()->methodName(),
            'message' => $event->throwable()->message(),
        ];
    }
}

The last subscriber is where the output happens.

use PHPUnit\Event\TestRunner\Finished;
use PHPUnit\Event\TestRunner\FinishedSubscriber;
use Tests\Extensions\TestDataCollector;

class TestsDoneSubscriber implements FinishedSubscriber
{

    public function __construct(private TestDataCollector $testDataCollector)
    {}

    public function notify(Finished $event): void
    {
        $this->testDataCollector->write();
    }
}

And this can now give an example output of

# Test results

## Summary

failed: 1
passed: 24
total: 25

## Messages

| Test | Message |
| --- | --- |
| App\Tests\AnswerTest::testFail | Failed asserting that false is true. |

Conclusion

Even if you don't need to format the output for AI agents I think you now have a better idea of what is possible.

Don't just git worktree

david duymelinck — Sat, 28 Mar 2026 06:03:19 +0000

I saw with the 2026 update of Jetbrains PHPStorm they are in on the git worktree hype.

I understand that it is a version control feature that creates less friction when there are multiple agents running and changing code.

The thing I don't understand is why would you think it is a great idea to let multiple agents change the same code parts?
If you are in charge of a team isn't it the first thing to divide the tasks so that they are isolated?
When they are not isolated isn't that a recipe for merge conflicts?

AI development feels like knowing to walk for years, and suddenly forgetting to do it because you can drive a car now.

The time animals could talk

Before AI exploded there were, and still are, many people that favored thunk based development. The main goal is to have less branches and if there are branches they should be short lived.

While I do think it is a great concept, like any other concept the usage depends on the conditions.
I have been in situations where clients asked for features and forget about them for weeks or months. I'm not comfortable dragging a feature along for months while keeping on with maintenance of the application.
When they decide to make feature a priority again, the first thing is to asset how much more work it is to get the feature code into the current codebase. It is a cost as a consequence of their behavior.

So feature branches can still be a valid solution while thunk based development is the default way of working.

Enter AI agents

An example I got from Claude Haiku:

Agent 1 writing documentation in one worktree
Agent 2 writing tests in another worktree
Agent 3 refactoring code in a third worktree

Agent 1 and 2 could be combined in my opinion.
Even if the documentation overlaps with the tests, why would it be a problem to use the same branch?
I'm the boss of the commits for now, but even if you let an agent commit the documentation files and the test files they don't overlap, right?

When you need to refactor code while maintaining the application, wouldn't you do that gradually?
And if a big bang refactor need to happen, wouldn't that take the priority over the other work?

Another question I have is who is checking the worktrees?
All fine that agents creates worktrees but in the end the worktrees need to be merged.
Isn't this the same scenario than the client forgetting about features for a period of time?

Now all together

Moving on I think we need to build on what we have learned working with human teams and use the parts that apply when AI agents are thrown into the mix.

If your situation needs git worktrees use them, just be sure that is the best option for your workflow.

https://batsov.com/articles/2026/03/09/emacs-and-vim-in-the-age-of-ai/ I gravitated to IDE's because of the GUI parts. I'm not a die hard terminal user. But with TUI's becoming better I'm rethinking my IDE use.

david duymelinck — Sat, 14 Mar 2026 09:08:15 +0000

Emacs and Vim in the Age of AI | (think)

It’s tough to make predictions, especially about the future. – Yogi Berra

batsov.com

Is good file naming becoming a thing of the past?

david duymelinck — Mon, 09 Mar 2026 13:54:17 +0000

As developers we heard for years naming is important.

The reason I write the post is the SOUL.md file, but lets go over the other bad naming choices AI companies made.

AGENTS.md

As I see it the file is the entry point for a coding agent to start exploring the project.

For years we are using README.md for the human entry point to our projects.
So why not go for AI-README.md or CODING-AGENT.md?

.project

To separate the coding agent permissions and other files from the project most of the coding agents use .project as one of the names they recognize. The other common name is the solution name, like .claude or .codex.

Why not use .ai? And in there one or more sub-directories can be added for solution specific things.

SOUL.md

The file as I see it is used to set agent boundaries.

The main gripe I have with that naming is that it humanizes AI. I think we all agree AI as it is now is not sentient. So it is even lower on the scale than an animal. So why give it a thing of ourself we can't even define ourselves?

CONSTITUTION.md seems like a more appropriate name.

llms.txt

While it is not a coding agent related file. I want to include it because the extension doesn't fit the content. The content is markdown.

This is even a bigger violation than generic naming.

Time for a body that governs the AI file naming?

AI isn't a language or a public asset like HTML, it is something in between.
The only thing is certain that AI is not going away, so we have to make long term plans.

The biggest problem will be to get the AI companies on board because they want to set their own standards.

Because LLM's and coding agents read every file you feed them, my solution at the moment is making the files and directories with my preferred naming explicit, for example as a system prompt.
The problem with this method is that the naming schemes will explode, because most people have their opinion about the names.

I feel when the naming is bad for those files/directories, how much are we going to care about the naming of the code files and even worst the code itself?
Or is this just a me problem?

PS: 5 days later I realize AI is the biggest misnaming so it really starts at the source. Having knowledge and the ability to learn isn't the full definition of intelligence. Understanding is the part that is missing, and it is the one that brings the two other parts together.

Thought-provoking https://terriblesoftware.org/2026/03/03/nobody-gets-promoted-for-simplicity/

david duymelinck — Wed, 04 Mar 2026 04:52:28 +0000

Nobody Gets Promoted for Simplicity – Terrible Software

We reward complexity and ignore simplicity. In interviews, design reviews, and promotions. Here’s how to fix it.

terriblesoftware.org

No code SSG

david duymelinck — Mon, 02 Mar 2026 09:26:01 +0000

I looked on skills.sh and skillsmp for an SSG skill and I couldn't find it.
So I thought I make a simple one with the developer knowledge I have.

The goals

Generate HTML files in the public directory.
Make it easy to detect errors in the source files after generating the website.
Add an intermediate feature like navigation.

The skill

The markdown reader of Github messed with the way I used sub lists.
The way I used sub lists is like you would use early returns in code.

The thing that surprised me the most is that temp/navigation.md file is written once during my tests with Claude code and Opencode.
I assumed when running the page agents in parallel, the file should be written to multiple times. The parallel running only happened in Claude code.

The other strange thing is that Opencode was quicker than Claude code. I used the Big Pickle in Opencode and Sonnet 4.6 in Claude code. The last test I did was 1 minute 57 seconds in Opencode and 3 minutes 24 seconds in Claude code.

Conclusion

I think most developers would have created a skill to generate code for the SSG. I was thinking about it for a few minutes too. But it is a bit silly to create code when an LLM can do the work.
It could be a fallback if the LLM is not reachable. But that is something I want to explore in a different experiment.

I spend 4 hour creating the skill and testing it. If I would have written the code by hand I think I would still be in the testing fase.
So I'm beginning to understand why software companies are getting devaluated. The job of a developer is now to access if the tasks can be done by an LLM or if code is still needed. And then there are many hybrid forms like skills with scripts and code that prompts an LLM.

In the "old" days event storming was used to understand the business process and the requirements. Now people can create a markdown file and read it.
I created a page agent to separate those specific actions. The more complex the process is the more and deeper agents will have to be to do the work.

While AI people only sell the system thinking angle when it comes to coding. You also need to know where programming languages shine, and for that you still need to have a deep knowledge of the language you are using. Because that are not the actions than can be vibe coded.

Laravel makes semantic versioning look bad

david duymelinck — Fri, 27 Feb 2026 21:14:00 +0000

Here I go again! I couldn't find it but I remember I did a rant about Laravel needing to pick date formatted versioning instead of semantic versioning when Laravel 12 was announced.

The reason I'm writing this is because Livewire can announce a release compatible with an unreleased major version.

Lets dive in.

Semantic versioning

The main goal of semantic versioning is to make the dependency management predictable.

It uses three sets of numbers divided by a dot. The context of the numbers from left to right is major, minor and patch.

A major number change must happen when there are backward incompatible changes. But it can also happen when multiple features and or changes are introduced.

The Laravel situation

From the commits on Github and a blog on Lavavel News The biggest change is the optional use of attributes.
While they added quite a few attributes, does this really warrant a major update?

You could argue raising the minimum required PHP version, 8.2 to 8.3, is cause for a major change.
When I look for an 8.3 feature like json_validate I see that they are are using the Symfony polyfill in version 12. So there is no need to raise the major version.

Why do they keep on using arbitrary semantic versioning?

Because it is the convention in the community?

There are no side effects if they are using the number parts as year, month and day. They could even add the time to the patch part in case they need to create multiple releases on a single day.
This means releases with backwards incompatible changes can only happen once a year.
I like the explicitness of the date versioning over the arbitrary number, you can actually see how old the version in the application is. This could open some eyes.

Are we doing semantic versioning wrong the whole time?
In the beginning of a project it is likely that backwards incompatible versions can be happen closer to each other. So in that stage the arbitrary numbering is preferred.
When the project is matured I think the step to date/calendar versioning should be taken.

PS: the post moved from rant to realization. But I kept the title for the views.

Markdown pages, are they a good solution?

david duymelinck — Tue, 24 Feb 2026 11:13:56 +0000

I already written a post about a HTML to markdown converter solution. In that post I suggested that the functionality on the application level would be a better solution. And in the last week Laravel markdown response and Symfony markdown response bundle popped up. I guess other languages with web frameworks will get similar solutions.

I consider those solutions to be partial fixes, because they lack the tools to trim or augment the page content for an LLM to get the data it can act on.
If you want to provide LLM content I think the best solution is a backend one instead of a frontend one. I consider fully created HTML as a part of the frontend.

The elephant in the room is that webpages are also a human construct.
An AI scraper doesn't need to follow human navigation. Page links are useless if it can grep the content.

How did we get here?

With search engine bots their goal was to find all the pages of a website to put them in a search index and rank them.

The purpose of AI bots is to scrape content from websites to use as additional knowledge for an LLM.

While scraping content was a part of the search engine bots, the content was not the main objective.

Search engine bots are also a minor part of the traffic. And are a part of the marketing cost, because they expose the website to a bigger audience.

AI bots are becoming a substantial part of the traffic, and they haven't proven their marketing worth or any other benefit.

It seems logical to me that the first reaction of people was to block AI traffic. When people discovered food wrappings contained less food the people were not happy. When food companies started to use lower quality products because their sales have reached the ceiling, the people where again unhappy.
The sad fact is people keep buying the product. And I think we are at the same level with AI. Websites are allowing AI scrapers because it could be beneficial.

What is the solution?

If you want to provide data for an LLM, I think an LLM website and a human website is a better way to go.
The LLM website can be nothing more than a collection of linked markdown files.

The second part of the solution is to provide a search that returns data an LLM or an agent can use. The main goal of the search is to provide specific information or information not found on the LLM website.
I don't think REST(ful) or Graphql endpoints are good enough because their output is not LLM specific.

The benefit of the LLM website is that they are static pages, so you could host them on edge servers when you see traffic ramping up in a certain region.
The benefit of a search is that you could create a paywall for AI scrapers to access the searchable content more frequently, or extra information.
The benefit of this solution is that HTML page traffic will be more human again, once the people that use the AI scrapers are aware of these options.

PHP fun: How to do operator overrides

david duymelinck — Sun, 22 Feb 2026 13:36:27 +0000

I just saw

and the thing that stood out to me was

api_check = is_admin() | (
    is_active()
    & account_older_than(30)
    & ~is_banned()
    & from_country(["NL", "BE"])
    & (credit_score_above(650) | has_override())

The reason is because this is tied to a class.

class Predicate[T]:
    """
    A composable predicate that supports &, |, and ~ operators.
    Wraps a function (T -> bool).
    """

    def __init__(self, fn: PredicateFn[T]):
        self.fn = fn

    def __call__(self, obj: T) -> bool:
        return self.fn(obj)

    def __and__(self, other: Predicate[T]) -> Predicate[T]:
        return Predicate(lambda x: self(x) and other(x))

    def __or__(self, other: Predicate[T]) -> Predicate[T]:
        return Predicate(lambda x: self(x) or other(x))

    def __invert__(self) -> Predicate[T]:
        return Predicate(lambda x: not self(x))

So I was thinking how can I do that in PHP.
And the answer is the Symfony expression language component
The component makes it possible to do.

$expr = 'is_admin($user) || (
    is_active($user)
    && account_older_than($user, 30)
    && !is_banned($user)
    && from_country($user, ["NL", "BE"])
    && (credit_score_above($user, 650) || has_override($user))
)';

$lang = new ExpressionLanguage();

// Register functions (compiler -> PHP code; evaluator -> runtime callable)
$lang->register('is_admin',
    fn() => '($user["is_admin"] ?? false)',
    fn(array $vars) => $vars['user']['is_admin'] ?? false
);

$lang->register('is_active',
    fn() => '($user["is_active"] ?? false)',
    fn(array $vars) => $vars['user']['is_active'] ?? false
);

// more register calls

$user = [
    'is_admin' => false,
    'is_active' => true,
    'created_at' => (new DateTime('-40 days'))->format('Y-m-d H:i:s'),
    'banned' => false,
    'country' => 'NL',
    'credit_score' => 660,
    'override' => false,
];

// Evaluate
$result = $lang->evaluate($expr, ['user' => $user]);

The register method is a bit clunky because the second argument is called when the compile method executes, and the third argument is called when the evaluate method is executed.

But the goal, having rules as data, is achieved.
It would have been nicer if PHP had operator magic methods like Python.
At least the PHP version can enforce type checking, which is not the case for the Python code.

For people who want to know more about the Python overloading methods go to Real Python.

Are markdown files becoming the new dot files?

david duymelinck — Sat, 21 Feb 2026 09:01:44 +0000

When you look at projects like Symfony, Astro or Ollama the first thing you see, after directories, are dot files.
Some tools abandoned the dot prefix and just use yaml or json files, and a rare xml file.

With AI tools we are seeing CLAUDE.md, AGENTS.md and other markdown files appear in the root directory.
For me this is straw that broke the camel's back.

The problem I have with the markdown files are the same that I have with the non-dot files, they miss context.
Dot files and folders are an old convention to signal configuration.

Most tools that use those configuration files have an option to specify the file. So it is possible to create a .tools folders and move all those files to that folder. Then use a makeFile to alias the tools with the config file.

The same could be done for AI markdown files.
The strange thing I discovered with Claude code is that it can use a .claude folder where you can place the config. But for scoping you need to add CLAUDE.md files to subfolders, this is worst than a root folder with many config files.
It looks like other people think scoping should be possible in .claude too.

What do you think? Is it time to clean up your application's root folder?

Update: After I wrote the post I found ai-coders-context. It seems to be more geared to switching from one AI tool to another. But it uses one folder, .context, to make it possible so it fits the cleaning root folder goal.