JohnnyCode.ai

JohnnyCode.ai Blog

90,000 Hours

A Coder’s Journey from PEEK to AI

Published

Illustration for 90,000 Hours

I’ve been coding almost every day since I was 12 years old.

Let that sink in for a moment. Not occasionally. Not as a hobby that comes and goes. Almost every single day for 41 years—minus holidays, vacations, and the occasional sick day. And as an adult, my workdays weren’t the standard 8 hours. They were 10. Sometimes more.

Recently, I got curious. What does that actually add up to?

The Math

Here’s the rough calculation:

Youth (ages 12-18): About 25 hours per week, 45 weeks per year, for 6 years = ~6,750 hours

Adult (ages 18-53): 50 hours per week, 48 weeks per year, for 35 years = ~84,000 hours

Grand total: Approximately 90,750 hours (we can round this down to~80,000 hours for some brief periods of burnout)

To put that in perspective:

  • That’s nine times the famous “10,000 hours to mastery” threshold. I’ve earned that badge nine times over.
  • It’s equivalent to 10.4 years of continuous, 24/7 coding without sleep.
  • A typical 40-hour-per-week developer with two weeks of vacation would need 45 years to match those hours.

But the numbers only tell part of the story.

From Bare Metal to the Cloud

When I started, there was no internet. No Stack Overflow. No AI assistant to help debug your code. There wasn’t even a hard drive on most home computers.

My first programs involved PEEK and POKE—commands that let you read and write directly to memory addresses. Want to put a letter on the screen? You’d literally poke a number into a specific memory location:

POKE 1024, 1    ' Put letter 'A' at top-left of screen
POKE 55296, 2   ' Make it red

One wrong POKE and you’d crash the entire machine. No undo. No recovery. Just a hard reset and the loss of whatever you’d been working on (assuming you hadn’t saved to that cassette tape recently).

If you wanted real speed, you’d drop into machine language—hand-entering hexadecimal values via DATA statements, then executing them with a SYS command. No compiler warnings. No IntelliSense. Just you, a reference manual, and raw determination.

10 FOR I = 0 TO 14
20 READ B: POKE 49152+I, B
30 NEXT I
40 SYS 49152
50 DATA 169,1,141,0,4,169,2,141,0,216,173,0,4,133,251,96

That DATA line? Those are actual 6502 processor instructions, encoded as decimal numbers. Each one matters. Miss a byte and nothing works.

The Evolution

Since those early days, I’ve lived through the entire modern history of software development:

  • Command line to GUI — From typing cryptic commands to clicking icons
  • Procedural to Object-Oriented — From spaghetti code to encapsulation
  • Desktop to Web — From standalone executables to browser-based applications
  • Monoliths to Microservices — From single deployments to distributed systems
  • Manual to CI/CD — From FTP uploads to automated pipelines
  • Solo to Collaborative — From floppy disk exchanges to real-time Git collaboration
  • Documentation to AI — From thick reference manuals to asking Claude for help

Today I work with C#, .NET 9, Blazor, Entity Framework Core, Azure DevOps pipelines, and yes—AI-assisted coding tools. The gap between POKE 1024,1 and await _context.SaveChangesAsync() is almost incomprehensible.

What 90,000 Hours Teaches You

It’s not about memorizing syntax. After 90,000 hours, you’ve forgotten more languages than most developers will ever learn. What you accumulate is something different:

Pattern recognition. You’ve seen this bug before. Maybe not exactly, but something like it. Your brain has indexed thousands of failure modes and their solutions.

Architectural intuition. You can feel when a design is going to cause problems six months from now. You’ve been burned enough times to recognize the warning signs.

Debugging instincts. You know where to look first. You know which assumptions to question. You’ve developed a sixth sense for what’s actually broken versus what looks broken.

Patience with complexity. You’ve learned that most hard problems aren’t solved in a flash of brilliance. They’re solved by methodically narrowing down possibilities until only the truth remains.

Humility. After 90,000 hours, you know exactly how much you don’t know. Every new framework, every new paradigm, every new language reminds you that mastery is a moving target.

The AI Inflection Point

Here’s what fascinates me about this moment in history: I’ve spent 90,000 hours building up pattern recognition and problem-solving instincts, and now AI systems are developing similar capabilities—but at a pace that makes human learning look glacial.

Does that make my experience obsolete? I don’t think so.

Those 90,000 hours taught me what questions to ask. They taught me how to evaluate whether an answer makes sense. They gave me the context to know when an AI suggestion is brilliant and when it’s confidently wrong.

The developers who will thrive aren’t the ones who fight AI or blindly trust it. They’re the ones who can collaborate with it—bringing human judgment, domain expertise, and hard-won intuition to the partnership.

Still Going

I’m 53, and I’m still coding almost every day. Not because I have to—I’ve more than paid my dues. But because after 41 years, it’s simply part of who I am.

The tools have changed beyond recognition. The problems have grown more complex. The pace has accelerated dramatically. But that fundamental joy of making a computer do something new? Of solving a puzzle that seemed impossible an hour ago? Of building something that didn’t exist before?

That hasn’t changed at all.

So long, and thanks for all the bits.

What about you? How many hours do you think you’ve invested in your craft? I’d love to hear your story.

First published December 30, 2025 on 42 Insights.

← All posts