Nobody tells you when it happens. One day you're a normal person who writes code for a living. The next, you're at a restaurant mentally refactoring the menu because the starters and desserts use inconsistent naming.

After nine years in this industry, I can confirm the condition is real. Here are the symptoms. Score yourself honestly.

The symptoms

1. You read error messages for fun

❌ A colleague's app crashes and you lean in like it's a good mystery novel. Stack traces don't scare you any more. They're the most honest documentation in the building.

2. Naming a variable takes longer than writing the function

❌ data? Too vague. tenantPaymentSummaryForCurrentPeriod? Too long. summary? Summary of what? Twenty minutes later you're still deciding, and the function is three lines.

3. You count from zero in real life

❌ "Take the zeroth exit at the roundabout." Your family has stopped asking what you mean.

4. "It depends" is your answer to everything

❌ Should we order pizza or burgers? It depends on group size, latency to delivery, and whether we need to support vegetarian clients.

5. You don't trust anything that works first time

❌ The tests passed on the first run. Instead of celebrating, you get suspicious and check whether the tests are even running.

(Honestly, this is a healthy instinct. A test you've never seen fail hasn't proved anything yet.)

6. You estimate everything, and you're wrong about everything

❌ "Fixing the shelf will take ten minutes." It's now Sunday evening, there's a new hole in the wall, and you've discovered the bracket has a dependency on a screw you don't own.

7. You've said "that's a feature, not a bug" about a household appliance

❌ The microwave beeps three times when it's done and once more a minute later. "That's actually a nice retry mechanism," you say. Nobody else agrees.

8. You have strong opinions about things nobody else has noticed

❌ Tabs vs spaces. Trailing commas. Whether a date should be 06/11 or 11/06 (it should be 2025-06-11, and you will explain why at length).

9. You check the logs before you check the obvious

❌ The Wi-Fi is down. You open the router admin panel, read the system log, check DNS settings and test with ping. The cable was unplugged.

10. You fixed a bug in a dream and it was wrong

❌ You wake up at 3 a.m. with the answer. You write it down. In the morning, the note says "just use a queue but backwards". Genius at 3 a.m., nonsense at 9.

Your score

• 0–3: You still have hobbies. Protect them.
• 4–7: Classic senior developer. You probably own a mechanical keyboard and have opinions about switches.
• 8–10: You named your pet after a design pattern. We should talk.

The useful part

Jokes aside, a few of these are worth a second look. The habits that make us good at work, like suspicion, attention to detail and always hunting for the cause, are tiring when they never switch off. Number 9 is funny until you realise it's the same habit that makes you skip the obvious checks at work too.

The best developers I've worked with share one habit that helps on both fronts: check the simple thing first. Is it plugged in? Is the service running? Is the .env the one you think it is? Did you save the file? Most "impossible" bugs die at that stage, and so do most weekend DIY disasters.

And when the laptop closes, let it stay closed for a while. The bug will still be there tomorrow, and you'll fix it faster after a proper night's sleep than after another dream about backwards queues.

So, what's your score? And what's the sign I missed that should definitely be number 11?