Programming

How I Realized I Can't Actually Code

A Senior Developer with 10 years of experience discovers that knowing frameworks and libraries is not the same as understanding computation — and that a single frozen CPU fan can expose a decade of blind spots.

I am a Senior Developer. Ten years of experience. Python, Java, modern frameworks — all under my belt. And then one day my script hung, the CPU pegged at 100%, and I sat there staring at the screen thinking: I have no idea what this machine is actually doing.

Code and complexity

The Illusion of Abstraction

Modern tooling is wonderful. .sort(), AutoML, third-party APIs — they compress months of engineering into a single line. They also create a comfortable distance between you and the actual weight of computation. Junior developers write nested loops over million-element arrays and feel nothing, because on a local machine with a small dataset, nothing hurts. Then you deploy to production with 10,000 concurrent users, and servers start falling over.

That gap — between manipulating tools and understanding what the machine is doing — is exactly what I had been living inside for a decade without knowing it.

The Problem That Exposed Me

Consider this: given a numerical triangle, find the maximum-sum path from top to bottom, where at each step you move to an adjacent neighbor below.

   3
  7 4
 2 4 6
8 5 9 3

Optimal path: 3 → 7 → 4 → 9 = 23. Seems straightforward. I wrote the obvious recursive solution:

def find_max_path(triangle, row=0, col=0):
    if row == len(triangle) - 1:
        return triangle[row][col]

    left = find_max_path(triangle, row+1, col)
    right = find_max_path(triangle, row+1, col+1)

    return triangle[row][col] + max(left, right)

For 15 rows, it finishes instantly. For 100 rows, it never finishes at all.

The Mathematics of Disaster

With 100 rows, the number of possible paths is 2⁹⁹ — roughly 6.3 × 10²⁹. Even a hypothetical supercomputer checking one billion paths per second would need approximately 20 billion years to finish. This is not a Python problem. It is not a memory problem. It is an algorithmic thinking problem.

I did not feel that. I had never been trained to feel it.

The Paradigm Shift: Work Backwards

The fix is elegant once you see it. Instead of guessing paths from the top down, start from the bottom. Each cell's true value is its own number plus the best contribution from its two children below. You compute this layer by layer, bottom to top:

for i in range(len(triangle) - 2, -1, -1):
    for j in range(len(triangle[i])):
        triangle[i][j] += max(triangle[i+1][j], triangle[i+1][j+1])

print(triangle[0][0])

Complexity drops from O(2ⁿ) to O(n²). Twenty billion years becomes 0.002 seconds.

This Pattern Is Everywhere

  • Photoshop's Seam Carving: Content-aware image resizing works by finding and removing minimum-energy paths through an image — the same backward-propagation logic.
  • Options Pricing: Binomial tree models collapse probability distributions from expiry back to the present, not forward from today.
  • Autocorrect: Levenshtein distance uses a dynamic matrix rather than brute-forcing every possible edit sequence.

Once you see the pattern, you see it everywhere. Until then, you don't even know to look.

How to Build the Intuition

I found Project Euler more useful than LeetCode for this specific gap. Project Euler problems are designed to look solvable by brute force — and then to brutally punish you when you try. There are 900+ problems, and working through them trains a visceral discomfort with O(2ⁿ) complexity that no amount of framework documentation ever could.

LeetCode teaches patterns. Project Euler teaches you to feel computational weight.

Engineering thinking

What Survives When AI Writes the Code

Frameworks come and go. jQuery gave way to React. React is giving way to AI-generated interfaces. The tools will keep changing. What doesn't change:

  • Recognizing when a brute-force approach is fundamentally unsolvable
  • The intuition to ask "can I work backwards?"
  • The ability to transform 20 billion years into milliseconds

Engineering thinking — the felt sense of computational weight — becomes more valuable, not less, as code generation becomes automated. If the AI writes the code but you can't tell whether it chose O(n²) or O(2ⁿ), you are not an engineer overseeing an AI. You are a user hoping for the best.

P.S. If ChatGPT can check algorithm complexity and write optimal solutions, why bother developing engineering intuition at all? That question is worth sitting with for a while.

Further reading