I Have OCD, But in Code

I have OCD. But in code.

Since day one of writing software, I've had this thing. I see bad lines. Bad variable names jump out at me. Dead spacing, unformatted code, copy-paste duplication, a project with no linter - I can't unsee any of it. It physically bothers me until it's fixed.

For a long time I thought of it as a quirk. Looking back, it was the single biggest reason my work turned out the way it did.

Quality over quantity, every time

Because of that obsession, every project I've worked on followed the same law: quality over quantity. Not as a slogan on a wall - as a reflex I couldn't switch off.

When I led Scrum teams and owned the architecture, it showed up in how I reviewed work. I never did one review. I did two:

1. A quality review - naming, structure, formatting, duplication. Is this written well?
2. A deep review - does the logic actually hold? Edge cases, data flow, the things that only break in production.

The first one is the part most people skip. To me it was never optional. How you write it is part of whether it works.

"Some thought I had a real problem"

I'll be honest: some people thought I had an actual mental health issue. The real clinical OCD. They'd watch me stop everything over a misnamed variable or a block that wasn't formatted and assume something was wrong.

But that wasn't it. It was never anxiety. It was just a standard for how things should be written.

It goes back to something my dad told me when I was a kid:

"If you did something, perfect it."

That one line became my rule. I've followed it ever since - in code, and in most things. And it really did do something. Over the years it compounded, quietly, into a place where I can look at my work and know it has real quality. Not because I'm talented. Because I refused to leave things half-done.

Then AI coding arrived

Then vibe coding and AI coding showed up, and a lot of developers started writing code blindly - accept the suggestion, move on, never really look at what landed in the file.

Here's the part people don't expect from someone like me: I love working with AI. It genuinely gave my life a push. I move faster, I build more, I reach further than I could alone.

But what about the "OCD"? Doesn't all that speed run straight into my need for things to be right?

It would - if I let it. So I don't.

How I keep the standard with AI

The trick is simple: I set the standard before the AI writes a single line.

Before I start, I lay down the foundation - the infrastructure, the base classes, the commons, the utilities - and a clear set of instructions or rules for the agent to follow. When that's in place, something clicks: the AI actually understands what I already have and what I want. It writes into my structure instead of inventing its own.

The discipline didn't disappear. It moved earlier. Instead of cleaning up after the code, I shape the space the code gets written in.

And this is where I'll be blunt with you: the tooling exists for a reason. ESLint. Lint rules. Pre-commit checks. Formatters. Use them. It is not a waste of time - it is the opposite. Those guardrails are how you keep quality while moving at AI speed. They catch the small things so you can think about the big ones.

The point

The obsession was never about being difficult. It was about caring how something is made, not just whether it runs.

AI didn't kill that. It raised the stakes. When a machine can generate a thousand lines in a second, the person who decides what good looks like matters more than ever.

So yes - I have OCD, in code. I'm keeping it.

If you did something, perfect it.