AI and rigor

AI accelerates execution, but without rigor, it accelerates debt. The engineers who thrive with AI are those who treat it as a force multiplier for discipline — not a replacement. This article shares the guardrails I use to ship faster without compromising maintainability.

Key takeaways

• Rigor is the multiplier for AI speed — not a constraint on it
• Guardrails (linting, tests, reviews) prevent invisible technical debt
• The goal is predictable, maintainable systems — not faster commits

Why AI Doesn't Replace Rigor

For as long as I can remember, rigor and discipline have guided how I live and work. I first learned these principles in martial arts as a teenager — where the training had a military-like structure and demanded full dedication. That mindset stuck with me. Today, whether it's in my work, my sport, or even organizing things with friends, I hold myself to strict standards. Some people find it irritating at first, but most end up thanking me for taking care of the things they didn't want to deal with.

This is why, when AI entered my workflow, I never saw it as a replacement for rigor. AI accelerates, yes. But rigor is what makes the acceleration sustainable.

The Temptation of Cutting Corners

I understand why people are tempted to let AI take over discipline. AI can spit out code very quickly, and when deadlines loom, it feels like a shortcut. I've done it myself in the past — everyone has. But rushing like this always comes at a cost. Even in a hurry, rigor shouldn't be optional.

I've seen coworkers use AI in a superficial way — dropping in prompts, copying the output, and pushing it. The result: messy code, hidden bugs, or worse, code that nobody wants to maintain. It's not AI's fault. It's how it's used. Without context, without validation, without rules, the outcome is garbage.

The Real Risk

AI is undeniably better today than it was two years ago. But even now, if you inspect the code closely, you'll find inconsistencies and errors in almost every corner.

The long-term risk is clear: teams end up stacking band-aid fixes. Developers ask AI to patch one bug, then another, then another. Soon the codebase becomes unreadable and unmaintainable. At that point, you don't need another band-aid — you need a full refactor. It's slower in the short term, but far more efficient in the long term. That's what rigor is about: investing care now to save pain later.

Guardrails and Process

For me, rigor isn't abstract — it's enforced through guardrails:

• Strict linting and TypeScript rules
• Unit and e2e tests wherever possible
• Deep code reviews and manual testing

AI-generated code must pass through all of these. Only then do I consider it ready.

I also use AI itself as part of my discipline. After a big change, I'll ask AI to review my work without context and give me pure analysis: what's good, what's missing, what could be improved. It's slower — I often iterate multiple times — but I end up with something robust and clean.

A Personal Example

During my Richemont mission, I refactored a feature that had its logic scattered across multiple files. Some pieces did exactly the same thing, others were tiny variations of the same idea. It was messy.

With AI's help, I turned it into two utility classes that now serve as the backbone of that feature. It took days of careful review and back-and-forth, because I wanted to fully understand and own the code. But in the end, the result was well-defined, easy to read, and easy to use. That's rigor amplified by AI — not replaced by it.

Why Rigor Matters Even More Now

Time has always been the excuse for messy code. "We'll fix it later." "Just ship it now." With AI, developers are faster than ever — which means there is no excuse anymore. If everyone is moving quickly, the differentiator is discipline.

For me, rigor means setting strict rules early and sticking to them. AI helps me multitask more easily — reviewing PRs while generating boilerplate, or testing one solution while iterating on another. But rigor is what ensures the code that comes out of it is reliable and enjoyable to maintain.

My Advice

For juniors especially, rigor is more important than ever. AI won't make you a great developer on its own. Discipline, knowledge, and experience are what give you an edge.

• Set rules and respect them.
• Own your code. Don't just accept AI's output blindly.
• Use AI as a learning boost, not a crutch.

In the end, rigor isn't optional. It's what makes AI a powerful tool instead of a dangerous shortcut.