Developing with AI without sacrificing quality: my workflow

"You use AI, so your work is worth less." I hear this more and more. It comes from an understandable intuition — if a machine writes the code, why pay a developer? — but it conflates two very different things: producing code and delivering a product that holds up.

A model generates lines. It doesn't decide the architecture, doesn't arbitrate between two technical trade-offs, doesn't think about accessibility, doesn't test under load, doesn't ask how the project will age in two years. That is the craft. And that is exactly what you pay for.

My rule is simple: AI is part of my tools, not my foundations. In practice, I use it where it excels and I keep control everywhere judgment matters.

• Research & exploration — cutting through documentation, comparing two approaches, understanding an obscure error faster.
• Prototyping — going from an idea to a first clickable version in a few hours instead of a few days.
• Documentation & tests — writing comments, generating test cases, spelling out a choice.
• Refactoring — suggesting rewrites that I read, correct and validate.

What I never delegate: the architecture, the data model, security decisions, the accessibility strategy, and the final review. That is where the difference between a deliverable and a real product is decided.

A generated site and a site that holds up in production can look alike on delivery day. Six months later, they have nothing in common.

The danger of AI isn't that it writes bad code — it often writes correct code. The danger is integrating code you don't understand. A piece of logic copied without being read becomes invisible debt: impossible to debug, to evolve, to secure.

My discipline fits in one sentence: I don't ship anything I couldn't rewrite myself. AI proposes, I decide. Every line that goes to production has passed through my understanding, not just my approval.

I don't limit myself to a single assistant, because they don't have the same strengths:

• Claude for long reasoning, reading dense code and rigor.
• GPT for quick ideation and certain targeted tasks.
• Generative tools (image, video) for visuals and interface prototyping.

Knowing which tool for which task is itself a skill — the same one as a craftsman who picks the right tool from the box, rather than doing everything with a hammer.

Using AI shouldn't lower a project's price. It should raise the value delivered at the same price:

• Shorter timelines on the mechanical parts, so more time for what matters: finish, tests, accessibility, performance.
• More complete documentation, because it costs less to produce.
• A better-thought-out product, because the time saved is reinvested in thinking, not cut from the invoice.

AI hasn't devalued development. It has shifted the value: from churning out lines toward judgment, architecture and quality. Those who master both — the tool and the craft — aren't cheaper. They're better.