If I Were 14 Again, Where Would I Start My Journey in Programming?

Introduction

In a dystopian world where AI generates 100% of the code, there would be no place to learn programming languages. It simply wouldn't make sense. But until that world arrives, we're in a stage where humans ask AI agents to create software and then humans supervise the generated code.

In this sense, knowing how to program still matters — although the "why" has changed.

In the current context where AI generates software that, in many contexts, approaches the level of a semi-senior profile (and will keep improving), the entry barriers for those who want to start in the world of programming have risen and transformed.

So, where to begin if knowing a programming language is no longer enough, doesn't help us differentiate ourselves, and in the extreme, wouldn't even make sense to learn?

🛠️ Before Writing the First Hello World: The AI-Native Setup

Before talking about what to learn, even before writing the first Hello World, we need to talk about what to work with: the AI-Native initial setup.

The starting point today, without a doubt, is code agents. So I would start by installing an IDE like Cursor, Windsurf, or Antigravity, integrated with one or more CLIs like Claude Code, Codex, Gemini CLI, or any other.

From there, I would learn how to build the ecosystem of agents, skills, commands, hooks, and MCPs. This would be the environment from which I would tackle everything that follows.

This is no minor detail: it's the working infrastructure of today's developer.

📐 Step 1: Algorithms

Now, back to the original question. I would start in the same place I started: algorithms. It's the foundation of programming and all logical thinking.

🧩 Step 2: OOP and Functional Programming

Next, I would understand the concepts of Object-Oriented Programming (OOP) and Functional Programming (FP) — not as dogmas, but as ways of thinking and structuring solutions.

🐍 Step 3: Choose a Language

Then I would choose a language — today it would be Python or JavaScript/TypeScript — and focus on understanding how OOP and FP are applied in those languages.

The goal here is not to memorize syntax (I still look up how to handle dates in Java; AI already knows it), but to understand the semantics in order to review what AI generates.

🌿 Step 4: Git — From Day One

In parallel with all of the above, and from day one, I would learn Git. Version control is not optional or advanced — it's the language in which software teams communicate.

🏛️ Step 5: Design Patterns and Principles

The next step would be learning design patterns and principles like DRY, KISS, SOLID, and The Twelve-Factor Manifesto. These are conceptual tools that allow better design decisions, regardless of the language or the problem.

🧪 Step 6: Testing

At this point, where we're already touching code, it's crucial to learn about testing: unit tests, integration tests, end-to-end tests, and the concept behind TDD.

Another key aspect is debugging and developing a critical eye to detect errors and question implementation decisions.

🗃️ Step 7: Databases

To store the data that software generates, I would dive into databases: relational modeling, SQL, and at least an introduction to non-relational databases.

⚙️ Step 8: CI/CD Automation

Next would be CI/CD automation — to avoid repetitive tasks and to integrate, validate, and deploy changes in an agile way.

🏗️ Step 9: Architecture Patterns

The next step: architecture patterns. Understanding how to create complete systems, how to divide responsibilities, and how to integrate them into a larger ecosystem.

🐳 Step 10: Containers

That would help understand the next topic: containers. I would learn Docker and Kubernetes, the patterns that revolve around them, the differences compared to monolithic software, and the trade-offs each decision implies.

🌐 Step 11: Deploying to the Web

Finally, I would learn how to make a system available on the web: domain and subdomain management, authentication methods, and basic application security concepts.

🗺️ The Full Roadmap at a Glance

#	Topic	Why It Matters
0	AI-Native Setup (IDE + CLI + Agents)	The developer's working infrastructure today
1	Algorithms	Foundation of all logical thinking
2	OOP & Functional Programming	Ways of thinking and structuring solutions
3	A Language (Python / JS/TS)	Understand semantics to review AI-generated code
4	Git	The language software teams communicate in
5	Design Patterns & Principles	Better design decisions regardless of language
6	Testing & Debugging	Critical eye for AI-generated code
7	Databases (SQL + NoSQL)	Store and model data
8	CI/CD	Automate integration and deployment
9	Architecture Patterns	Build and understand complete systems
10	Docker & Kubernetes	Containers, patterns, and trade-offs
11	Web Deployment & Security	Make it available to the world

🎯 Final Thoughts

There are many other topics that could be added — Big O Notation for Time and Space Complexity, how APIs work (HTTP, REST), how data is structured, how systems interoperate — but I think the points I mentioned are a good foundation, or at least a good initial map to get started.

It's hard to list them one after another as if they were a sequence, when in reality they're not. The order is not random, but it's not rigid either. It's based on my experience as a professional and educator, seeking to progressively increase the level of complexity and abstraction.

In practice, you learn by doing. Many of these concepts intertwine and are learned simultaneously while building a real product.

Each point on this map is, in itself, almost infinite, and there are experts in each of them. It depends on the individual how deeply to approach each topic and which ones to focus on.

As engineers, the most valuable thing is to develop a global vision and be able to get involved in all aspects of a software product — even though there will always be areas where one has more mastery than others.

📚 Resources

Original LinkedIn Article (Spanish) 👉 Post & Article: Si hoy tuviese 14 años, ¿por dónde empezaría mi camino en la programación?