Learning New Things When You're Already Senior: Why I Keep Feeling Stupid Again

I've been coding for 8 years. Good at React, Node, Postgres, Docker, AWS. Every new project, I know how to approach it. See a codebase, the structure is already in my head. IDE shortcuts are muscle memory. Production debugging is routine. I felt "I'm senior, I'm good."

Then 2 months ago I wanted to learn Rust. I thought "I'm good at 5 languages, this is just the 6th. Probably 2 weeks done."

2 weeks later, I was still struggling with ownership and borrowing. Took me 3 hours to write code that in Python takes 10 minutes. I felt stupid. Not "slow" - stupid. Code I wrote wouldn't compile, I didn't understand why. Rust error messages explained something I didn't understand the concept of. I, who usually reads documentation and gets it in 5 minutes, was reading for 30 minutes and still confused.

That was the moment I realized: learning new things when you're already senior is a different experience. Not just "learning again." There's psychology I wasn't prepared for. There's ego that has to be checked. There are expectations that need resetting. This isn't about "how to learn Rust." It's about why learning new things when you're already good is actually harder than when you first learned to code.

---

The Problem Isn't the New Language. The Problem Is Ego.

When I first learned Python (2017), I had no expectations. I was a beginner. Slow = normal. Not understanding = normal. Learning something new every day = expected.

When I learned Rust 2 months ago, I already had the expectation "I'm senior." This expectation is what made it hard, not Rust itself. Every time I didn't understand something, my brain said: "I should already get this. I've been coding for 8 years. Why am I confused?"

Comparison that makes it clear:

| Aspect | First time learning (2017, Python) | Sixth time learning (2025, Rust) |
|---|---|---|
| Expectation | Beginner, normal to be slow | Senior, should be fast |
| Ego | No stake | High, "I'm already good" |
| External validation | None yet | Already exists (salary, title, respect) |
| Frustration | "Don't understand yet" | "Should already understand" |
| Mindset | "Learning" | "Just adding a skill" |
| Time to learn | 1-2 hours/day, enough | 1-2 hours/day, not enough (need to unlearn) |

The philosophy I found: learning new things when senior is 2x harder, not because the material is 2x harder, but because you have to do 2 things at once: learn the new thing + unlearn old patterns.

---

"Unlearning" Is the Most Painful Part

Concrete example from Rust. In Python/JS, this is valid:

Python - easy, familiar
items = [1, 2, 3]
first = items[0]
items.append(4)
print(first) # 1, no problem

In Rust, the "equivalent" doesn't compile:

// Rust - error: borrow after move
let items = vec![1, 2, 3];
let first = items[0]; // borrow
items.push(4); // mutable borrow - error!
println!("{}", first);

Error: "cannot borrow items as mutable because it is also borrowed as shared." For someone who's never heard of a "borrow checker," that sounds like alien language.

In Python, my brain is already wired: "variable = reference, everything is allowed, GC handles it." In Rust, my brain has to learn: "variable has an owner, if borrowed immutably, can't be mutated."

Unlearning = overriding reflexes that are already automatic. Not adding new knowledge. Dismantling the old. That's what's heavy.

Like an acoustic guitar player learning electric guitar. Tuning different, technique different, but what's the same: fingers are already used to certain positions. Learning new chords is hard, but harder: changing finger reflexes that are already automatic.

When a senior learns something new, 70% of the effort is "learning the new." 30% is "unlearning the old." That 30% is what causes frustration. Your brain automatically uses old patterns. Every time you realize you used an old pattern, you have to actively stop, remember the new pattern, execute. Every time you forget, you revert to the old pattern. Every time you revert, frustration rises.

---

Dunning-Kruger and the Senior Dev

Dunning-Kruger effect: people who are new to something overestimate their ability. The classic graph: starts at "Mount Stupid" (very confident despite knowing little), drops to "Valley of Despair" (realize how much they don't know), climbs slowly to "Slope of Enlightenment," finally "Plateau of Sustainability."

What I learned: a senior dev learning something new starts at the peak of the plateau (in their old skill). Then moves to a new topic, immediately drops to the Valley of Despair. That's the steepest drop. From "I'm good" to "I don't know anything" within 1 week.

That drop is what's not prepared for. Not "I haven't learned yet." The sensation: "I thought I was smart, turns out I'm stupid." Ego takes the hit.

When juniors learn, they climb from 0. Every progress = up. Sense of progress. When seniors learn, they drop from 100 to 0 first, then climb slowly. Sense of regression before sense of progress.

The philosophy I hold now: if you're senior and learning something new, you have to accept that you'll feel stupid. Not "look stupid" - actually be stupid in that topic. Ego can't get involved. You are a beginner in the new topic, even if senior in the old.

---

The Right Mindset (Which I Struggle to Hold)

1. "Beginner's mind" isn't just a slogan.

Zen concept: shoshin, "beginner's mind." Read about how seniors learn. The point: if you come in with a head full of "I already know," you won't learn. You have to come with a head of "I don't know anything."

Implementation is hard. Every time I read Rust documentation, my brain says "ah, this is like C, I already know pointers." Then I skip reading, jump to coding. Error. Turns out Rust references are a different concept from C pointers. I have to go back and read, this time with ego lowered.

// I thought &mut was like a pointer in C
fn modify(val: &mut i32) {
*val += 1;
}

// But Rust has a rule: 1 mutable borrow OR many immutable borrows
// Can't have both simultaneously
let mut x = 5;
let r1 = &x; // ok, immutable borrow
let r2 = &x; // ok, multiple immutable borrows allowed
let r3 = &mut x; // ERROR: cannot borrow as mutable, already borrowed as shared

I needed 1 week to understand why Rust is strict like that. Not because Rust is complicated, but because I had to unlearn the Python/JS mindset where "everything is a reference, free to use by anyone."

2. Compare, but don't dismiss.

One of the fastest ways to learn: compare to what you already know. "In Python list.append(x). In Rust vec.push(x). Same but different name." That helps.

But it's dangerous if comparison makes you dismissive. "Ah, Rust is complicated, Python is just 1 line." You're not learning to compare which is "better." You're learning to understand why Rust is designed that way. Every language has a philosophy.

Rust's philosophy: "memory safety without garbage collector." That's why the borrow checker is strict. Not because the creators wanted to make it hard for you, but because safety is the primary goal. If you dismiss "Complicated, I'll stick with Python," you won't understand why Rust wins in certain use cases (system programming, embedded, performance-critical).

3. Pick a small project, not a tutorial.

I tried learning Rust through tutorials. 1 week reading "The Rust Programming Language" book. Understood concepts, but couldn't write. When I tried to write, blank.

Switched strategy: build a small project. HTTP server using axum, endpoint /health that returns JSON. 50 lines of code. In those 50 lines, I hit every concept: ownership, borrowing, Result type, async, error handling. Every error = learning.

// My first 50 lines in Rust
use axum::{Json, routing::get, Router};
use serde::Serialize;
use std::net::SocketAddr;

#[derive(Serialize)]
struct Health {
status: String,
uptime: u64,
}

async fn health() -> Json {
Json(Health {
status: "ok".to_string(),
uptime: 0,
})
}

#[tokio::main]
async fn main() {
let app = Router::new().route("/health", get(health));
let addr = SocketAddr::from(([0, 0, 0, 0], 3000));
println!("Listening on {}", addr);
axum::Server::bind(&addr)
.serve(app.into_make_service())
.await
.unwrap();
}

50 lines. 2 days to write (in Python: 5 minutes). But in those 2 days I learned more than in 1 week of reading the book. Because learning = active struggle, not passive consumption.

---

What I Learned on a Deeper Level

Learning isn't accumulation. Learning is transformation.

I thought learning = adding knowledge to my head. Wrong. Learning = changing the cognitive structure of your brain. Your brain has to rewire to understand new concepts. That's what's heavy.

Imagine I have "bookshelves" in my brain: React, Node, Postgres, Python, Docker. Each shelf has its own structure. Rust arrives, I make a new shelf. But the Rust shelf can't be empty - I have to fill it with concepts that don't exist on other shelves (ownership, lifetime, zero-cost abstraction). Every time I want to place a Rust concept, I have to check other shelves: "Is this like in Python? No. Like in C? A bit. Make a new shelf."

That process = transformation. Not adding an empty shelf, but modifying the entire structure. That's why it's tiring. Not because there's a lot of material, but because your brain is actively restructuring.

The sense of progress disappears, then reappears.

When I was learning Python, every day there was a sense of progress. Day 1: print hello world. Day 2: if-else. Day 3: functions. Every day clearly climbing.

When I'm learning Rust now, the first 2 weeks felt stagnant. Every day reading documentation, every day not understanding. Day 15 was when it "clicked" - everything I'd read for 2 weeks made sense. The sense of progress isn't linear, but a step function. Stuck for a long time, then suddenly up. Frustration before the click.

The philosophy I hold now: learning new things = investment with delayed returns. You invest 2 weeks, get nothing. Then in week 3, it all clicks. The sense of progress only appears after you've invested enough. As a senior, you're used to "invest 1 hour, get 1 hour of result." Learning new things: invest 10 hours, get 0. Next week invest 10 hours again, get 0. Only 5 weeks later, get 100. Not linear. That's what has to be mentally prepared for.

---

Signs You're Struggling with the Senior Learning Plateau

• You write code, it doesn't work, and immediately feel "I'm bad" not "I haven't learned yet"
• You compare yourself to juniors who are already good at that language, feeling insecure
• You read documentation, don't understand, get frustrated - even though you used to understand any doc in 10 minutes
• You start thinking "maybe I'm just not suited for this language" when the problem is just that 2 weeks isn't enough
• You skip fundamentals, jump to coding - when you get errors, you don't understand why because your fundamentals aren't solid

Every sign above = ego struggling. Not a lack of skill. A mindset that needs adjusting.

---

An Honest Closing

Learning new things when you're already senior is an experience I wasn't prepared for. I thought "I'm senior, it'll be easy." No. It's actually harder, because of ego, because of expectations, because you have to unlearn.

The philosophy I bring now: if you're senior and learning something new, you have to kill your ego first. You are a beginner in the new topic, even if senior in the old. Accept that. No shame in asking. No shame in being slow. No shame in not understanding error messages.

Rust 2 months later: I'm still struggling, but I can now write an HTTP server, a CLI tool, small scripts. Still slow compared to Python, but every line of code I write in Rust, I understand why I'm writing it that way. That's the difference from Python - I write Python because it's familiar, I write Rust because I understand.

I won't say "Rust is better than Python." I'll say: learning Rust changed how I think about memory and ownership, and that way of thinking back-influences how I write Python. Learning new things doesn't just add skills, it changes how you see things you already know.

If you're a senior struggling to learn something new: you're not alone. It's normal. Your ego is what's not normal - too high. Lower it. You're a beginner in the new topic. Start from there.