Learning to code today is weird.

The software engineering job market was NUTS just 4 years ago. Now, the job market is constricting. Sure, some of it’s due to macro stuff, but plenty of the pressure is from AI.

When ChatGPT came out, I quickly started using to help me program. Some syntax lookups here, some bug hunting there.

Then came Cursor. Shortly after, Claude Code. In-between, Replit, Lovable, v0, etc. Programming has changed, and it changed FAST. You can build apps that used to take days-to-weeks in less than an hour. You can do real software engineering work without actually writing a single line of code.

Some people are interpreting this as the end of the profession, but I don’t think software engineering is going away completely.

I think the best engineers 5 years from now are going to be the ones that understand programming incredibly well and leverage AI tools effectively.

If you want to be a software engineer, you should still learn to program (even if vibe coding tool startups are telling you otherwise).

Learning to code is changing

If I were starting from zero today, I’d approach learning to code very differently than people did even five years ago.

The optimal path to a career in tech has changed. Junior developer jobs are getting eaten by AI because AI can write a shocking amount of code now. That’s both a cheat code and a trap.

You can ship real things faster than ever without ever building the mental models that make you dangerous in a codebase. This will cause you problems in a real development job.

You should bother to learn to actually program.

Here’s exactly how I’d do it.

60% fundamentals, 40% building stuff (with AI)

If you only build projects with AI, you’ll get dopamine and cool screenshots for a portfolio, but you’ll build a shaky foundation that will cause you real problems.

If you only study fundamentals, you’ll get theory and no momentum, forcing you to move slower than you actually have to move.

So I’d split it:

• 60% fundamentals: learn the mechanics and mental models
• 40% building: ship small apps using tools like Cursor to accelerate learning

You need both at the same time. I’ll show you the exact steps I’d follow, but first, a word about debugging.

Debugging is the skill that makes you a real programmer

This is the part beginners skip in the age of LLMs, because AI “fixes” lots of bugs without much effort from you.

I would make debugging a first-class skill from day one.

You need to get comfortable with:

• reading an error message without panicking
• reading a stack trace and finding the real failing line
• reproducing bugs reliably
• inserting print statements or using a debugger
• narrowing the problem (what changed, what assumptions are false)
• understanding what the program is doing, not what you wish it were doing

I can NOT stress enough how important it is to be able to read and understand a stack trace.

Here’s a rule I’d follow:

Never paste an error into AI until you’ve read it, located it in code, and formed a guess about what it means.

Even if your guess is wrong, that act is building your brain.

Because the people who “make it” in software are the ones who can stare at a broken system and methodically force it to make sense.

Step 1: Pick one mainstream language and commit for 3 months

Pick Python or JavaScript. I’d say pick Ruby because I love Ruby, but the job market for Rubyists is weird.

Pick one, commit, and start.

• Pick Python if you want the smoothest “learn to code” ramp.
• Pick JavaScript if you’re excited about web apps and want to build in the browser.

You can learn the other later. The first language is mostly about learning how programming works.

Step 2: Do one intro course, then stop taking courses

I’d do one solid beginner YouTube course to get the basics:

• variables, functions, loops, conditionals
• data structures (arrays/lists, hashes/objects)
• basic I/O
• modules, packages
• how to run code and install dependencies

Courses feel productive, but they’re a passive form of learning past the initial ramp.

After that, you need actual reps.

Step 3: Grind LeetCode (Easy) for one reason: fluency

Yes, LeetCode. This is good training for interviews at least for now (tech companies are quickly making interviews AI-first).

The main reason to do this is it to build muscle memory and learn the core data structures and algorithms without hiding behind frameworks.

What I’d do:

• Do a ton of LeetCode Easy.
• When you get stuck, ask AI for hints, not answers.
• After you solve it, rewrite it from scratch the next day.

You’re trying to internalize arrays/lists, strings, hash maps / dictionaries, stacks, queues, recursion basics, sorting/searching patterns, and time complexity intuition (you don’t need to be a wizard, just not clueless about how your code handles growing inputs).

This is where you build the “I can reason about code” brain. You can even use AI as a LeetCode coach!

I would do step 3 in parallel with step 4.

Step 4: Build tiny projects, but earn the right to use less AI

I would do this step in parallel with step 4 (the above).

This is where Cursor (or similar tools) becomes a huge advantage.

But I would be intentional about it.

I’d build 3 to 5 basic apps:

• To-do app
• Flashcard app
• Medicine tracker
• (optional) habit tracker, simple budget app, workout logger

The rule is: small, boring, complete.

Use AI to speed you up, but add constraints so you’re still learning:

You keep doing this until you can build one of these apps without leaning heavily on AI.

Step 5: Don’t go fully agentic until you’ve gotten reps

Agentic tools like Claude Code are incredible. They’re also dangerous for beginners.

So early on, I’d skip the “AI goes off and does a bunch of stuff” approach.

Stick to an interactive tool like Cursor, where you’re still steering, still reading diffs, still making decisions.

Earn the right to go more agentic later.

The milestone I’d hit before “committing” to a career in programming

Before spending years on a CS degree, bootcamp, or career switch, I’d want to prove something to myself:

I can build a small app end-to-end, understand most of the code, and debug common issues and not hate the process.

It will take time to gain this level of competency. If you can’t get there, you might still eventually become a great engineer, but you should learn that before you commit major time and money.

If you do commit, use more agentic tools, but keep deliberate practice

Once you have baseline competence, it’s completely fine to lean harder into AI, including agentic workflows.

Just keep one habit alive to avoid skill atrophy:

Always have a “learning mode” for some portion of your work.