Skip to content

2 years of AI adoption: lessons from a freelance SEO & Developer

By Updated at 11 min read

etabli-outils-artisan.jpg - 69a4d26ec0176

rm -rf

An AI agent ran it on what it thought was a temporary folder.

It was a shortcut to a production image library.

10,000 files, gone.

Thank god for backups, and thank my fifteen years of developer reflexes that had set them up.

Are you more of a claude --dangerously-skip-permissions type, do you approve every action by hand, or haven’t you taken the leap yet?

I’ve been building my daily workflow with AI for two years now, as a developer and SEO consultant.

Neither evangelist nor skeptic.

Just a craftsman who wants to know if the new tool deserves a spot on the workbench.

Here’s what I’ve learned, crashes included.

  1. False starts: Chatbot | Copilot
  2. AI in my tools
  3. The agent in the IDE
  4. 1 month compressed into 1 day
  5. My current stack
  6. Human in the loop
  7. What I take away: Experience and curiosity, not the model | FOMO

1. False starts

My first contact was ChatGPT. Like most people.

You ask a question, you’re impressed. Then you dig deeper, leave the textbook case, and the magic fades.

In web development, copy-pasting code from a chat, fixing, re-pasting, re-fixing… a constant back-and-forth that costs more time than it saves.

The chatbot remains useful for a quick check, a brainstorm, a sanity check.

On the SEO side, it already speeds up content production: first drafts, title tag rewrites, variations to avoid duplicate content.

On the customer service side, it absorbs the responses that don’t require my expertise.

That reflex, by the way, is what later led me to build my AI email assistant for my second job.

GitHub Copilot in VS Code

Real-time autocomplete. Suggestions sometimes on point, sometimes off. The chatbot in the same interface as the IDE.

The gain was measured in seconds, not hours.

I cancelled.

2. AI in my tools: the real turning point

The real shift is when AI accesses your context without drowning in it: your files, your terminal, your APIs.

When it can act, not just talk.

The turning point is when I stopped using AI through a product and started integrating it into my own tools.

I have an in-house SEO analysis tool.

It crawls sites, tracks Google rankings, extracts semantic data, identifies targeted keywords, suggests missed keywords.

A dashboard I use daily with about fifteen API endpoints that, until then, were underused: Google results, search volumes, backlinks, per-site stats, diffs between two crawls…

The day I plugged an LLM into it, the leverage appeared. And it’s leverage nobody can replicate with a prompt and a chatbot: you need the tool, the data, and years of SEO practice to know what to do with it.

I run a content strategy audit. I send the model current rankings, targeted keywords, related queries, crawled competitor content, semantic data and business context. The LLM cross-references everything faster than I could. It produces recommendations anchored in the site’s real data, not generic advice.

I focus on what matters: making decisions.

Over two years, I’ve refined the process. At first, I was generating utilitarian SEO content, correct but bland.

Today, it carries the voice of the brands I work with.

Another example. An e-commerce client with dozens of product pages sharing the same wording. Classic duplicate content. The problem isn’t just SEO but also UX. A user comparing 2 products lands on similar texts and lacks the information to choose.

AI rewrites each page based on real differences between products: technical specs, use cases, target audience. The distinctions existed in the data, they just weren’t showing in the copy. After rewriting, each page genuinely helps the user make their choice.

A pinch of listing pages to structure the browsing experience, and the site becomes navigable (and increases its organic visibility).

Weeks of writing compressed into a few days of supervision. The result surpasses what a copywriter tired of repetition or a well-tuned content spinner produces, because each page is genuinely unique.

This isn’t mass-generated content. It’s content that should have been unique from the start, and finally is.

Today, I’m scaling up. Really scaling up. Check back in a few weeks to see if the ladder holds.


Garbage In, Garbage Out. AI doesn’t replace expertise, it amplifies it. Without domain knowledge, the LLM produces hot air. With data, business context and an expert’s eye, it becomes a multiplier.

Data, business context, expert eye: without these three ingredients, AI is just a dumb parrot.

How far have you pushed these 3 ingredients? Let’s talk about it on X.


3. The agent in the IDE: learning to supervise

The next step is the agent integrated into the IDE. A tool that reads files, understands projects, runs commands.

No more copy-pasting from a chat. The AI works directly in the project.

I started with Cursor, tested Windsurf and Cline in parallel, had a go with Antigravity. Each has its strengths, but the logic is the same: giving the model direct access to code and terminal.

The rm -rf I mentioned in the introduction happened here, experimenting in Yolo mode to fix a bug in production.

And that’s where automated tests take on their full meaning. The airport security gate: it’s not you checking every passenger, it’s the system.

Your job is to make sure the gate works.

At first, I checked every line, every commit. Then I built trust by investing in quality gates: unit tests, automated code quality checks, tests that simulate real user journeys. If the gates go green, the commit can pass.

AI proposes, tests dispose. It adjusts. I keep an eye.

You shift from micro-management to supervision. The freed mental energy, I reinvest in architecture, product vision, strategy. And incidentally, I burn brainpower orchestrating up to ten refactorings in parallel.

I learned to let AI explore its own direction. Before, I wanted it to code exactly like me. Now, I trust it can do better and faster.

Today, I let it go. When needed, I course-correct.

And sometimes it’s the reverse: I use it to skill up on a technology I don’t know. AI becomes a patient tutor who codes with you, not instead of you.

4. 1 month compressed into 1 day with Claude Code

Late 2025, I dropped Cursor for Claude Code. The results were better. Stacking subscriptions no longer made sense.

My setup today: VS Code, Claude Code, $200/month.

I’m not an early adopter. But when a tool does the job, I settle in and learn it in depth rather than chasing every alternative.

And then there was this project that landed at the same time.

A travel portage agency for independent guides. Sales funnel with payments. Membership system with degressive commissions. Pro dashboards per guide. Expense and fee management. Business referral tracking between cooperators.

The kind of project where you spend more time modeling business rules than writing code.

I prepared a brief. Not a three-line prompt. A real specification document: architecture, business constraints, use cases, tech stack.

Claude produced the functional back-end in one day. Models, business logic, API, role management, the heavy lifting.

One day. For what would have taken me a month.

Let’s be honest: the front-end, UX, back-and-forth with future users, daily maintenance, that doesn’t compress the same way. AI massively accelerates code production, much less human iterations. The project is currently launching, and it still demands time every week.

What really changed is the ratio. Writing precise specs upfront, designing architecture, anticipating edge cases: that’s developer expertise, not “prompt engineering.” A freelancer without a system, without their own tools and without architectural experience doesn’t replicate this by copying a prompt.

In parallel, I’ve been pushing the CMS that allows me to pivot most of my projects toward smooth AI workflows.

I develop Pushword, an open source CMS built on Symfony, designed SEO-first (by an SEO consultant, naturally). Multi-site native, flat file (content stored in simple text files), static generation, page versioning, page scanning (dead links, internal, external, anchors, redirects, email, phone…).

It’s become my go-to stack, and the one I offer my clients. The reason is simple: flat file architecture removes friction with AI. No admin panel to navigate, no REST API to query. The agent reads and writes directly in markdown files. One command (pw:page-scan), and I know if a link is dead, a redirect broken or an anchor missing (or rather, the AI knows and fixes it).

For AI content production workflows, this is exactly the type of CMS you need: transparent to the machine, comfortable for humans (visual block editor, Notion-style, when you prefer a GUI). It’s this complete pipeline (expertise > SEO & GEO tool > API > LLM > flat file CMS > live) that makes the difference for my clients. Not AI alone.

The first e-commerce site powered by Pushword just launched (connected to the client’s CRM via API).

Since then, I’ve been tooling all my recurring processes the same way: configuration files, reusable system prompts, scripts that orchestrate my SEO API with Claude.

Each task has its own context and guardrails.

My current stack (last updated August 2026)

This article will be kept up to date as my usage evolves. Since the ecosystem changes every three months (goodbye Copilot, farewell Cursor), here’s a snapshot of the workbench right now.

A minimalist setup, centered on control and speed:

  • Model: Claude Opus 4.6. Currently the model that “reasons” best on complex tasks.
  • The interface (IDE): VS Code “vanilla”, meaning Codium. I’ve uninstalled integrated AI extensions. I prefer using the terminal to interact with the agent, which spares me the distraction of constant autocomplete (I almost never edit code by hand anymore).
  • The agent: Claude Code (CLI), Codex currently under evaluation, and occasionally OpenCode
  • The web framework: Pushword. My flat-file CMS. The absence of a SQL database makes the AI’s work easier: it reads and writes directly in the site’s markdown files. For client work, I work with WordPress (REST API) or Drupal (hello Puppeteer).
  • SEO & GEO tooling: A custom-built software suite giving me unlimited access to all collected data, organized and sorted (position tracking, backlink monitoring, crawl analysis).

Monthly operational cost: around $200 (mainly subscription, API equivalent is more than $4.000).

Global skills

The list below is the shared foundation. On top of it, each project stacks its own skills: business prompts, client context, specific tooling.

Dev related

  • dev-browser: Browser automation (navigation, screenshots, scraping), token-efficient, equivalent to the Chrome MCP
  • code-simplifier / improve-php-codebase / code-html-enhancer: variations of a skill that has since been absorbed into Claude Code itself (/simplify)
  • fix-stan-low - Haiku / fix-stan-advanced - Sonnet : fix phpstan reported errors
  • document / update-claude - Sonnet
  • popcash-api-promote - Haiku : 🙌
  • commit / tagAndPush - Haiku

Content

  • find-gpx / clean-gpx: Search, download and clean GPX tracks from a GPX library
  • find-image / find-video: Search for a photo/video from a {provider}

General

  • summary - Haiku : Generate a standup summary of the session (for when I lose track across 10 open sessions at once)

Human in the loop

Just as important as what AI does well: knowing where not to use it.

Publishing stays human. Blog post, product page, client email: content that bears my name gets reviewed and validated. AI prepares, structures, suggests, improves.

The final word is mine.

My reputation rests on the authenticity of what I publish. A text that “smells” like AI, even subtly, is lost trust.

On the other hand, I let AI commit on my projects. Unit tests green, code quality automatically verified, user journey tests passed: the code ships.

Code has objective, automatable guardrails. Editorial content doesn’t. No automated test can verify whether a text sounds right, stays true to your voice, or will resonate with your audience.

What I take away

Experience and curiosity, not the model

AI amplifies what you already know. It doesn’t compensate for what you don’t.

Knowing what to ask, evaluating an answer, spotting when the agent goes off track, architecting a technical brief: all of this builds on years of practice or a genuine willingness to learn. Experience remains the real lever, not the model.

Without that, you’re just accelerating the production of mediocrity. There’s a word for it: AI slop.

AI FOMO

In theory, AI saves me desk time to spend more days outdoors.

In practice (and maybe like you), I spend the saved time exploring new AI workflows or keeping up with the latest.

The FOMO is real. Note to self: things move too fast for anyone to be “up to date.” What helps me is keeping my feet on the mountain, literally and figuratively.


Improving my email assistant with Claude Code, industrializing my SEO processes via a skills framework, open source LLMs (sovereignty, cost, curiosity), image and video generation… The list isn’t getting shorter.

In six months, this article will probably already be outdated.

That’s the game. Have fun ✌️

AI, SEO and Web strategy session

Where will AI create real value for you?

Move from watching the market to setting priorities, based on your processes, data, and the actual cost of the problem.

Prioritize my AI use cases

€350 excl. VAT, up to 90 minutes

And if you’d like to receive its updates:

Email • RSS • Twitter

Get notified of new posts