“Live as if you were to die tomorrow. Learn as if you were to live forever.” - Mahatma Gandhi
In tech, you never stop learning. But the way you learn changes over time. What feels perfect at the beginning can become a roadblock a few years later.
This is my personal story of how my learning stack evolved from in-person IT school to video courses, from reading the docs while building pet projects to structured, practice-heavy programs, and finally to a cautious relationship with AI.
If you recognize yourself in any of this, you’re not alone.
Stage 1: IT Bootcamps (IT School) as a Beginner’s Compass (2018)
Coming from a completely different field, I needed three things that self-study couldn't provide:
- Structure - a clear, well-designed curriculum with the right topics in the right order.
- Support - mentors and instructors you can turn to when you’re stuck - they can unblock you and help you move forward.
- Community of peers - fellow strugglers who understood why a missing semicolon could ruin your entire evening.
At this stage, scattered video tutorials and mini-courses on individual technologies felt like trying to build a house by randomly collecting bricks. They lacked the comprehensive, systematic approach I needed.
The bootcamp (in my case, an IT school program) became the obvious choice. In-person attendance added the necessary atmosphere and drive - there's something about physically showing up that makes you take it seriously. Team projects with coursemates and a community to discuss solutions accelerated the process exponentially. Nothing beats the "aha!" moment when you explain your bug to someone and suddenly realize the solution mid-sentence.
That's how I entered the programming world through a Full-Stack JavaScript Developer program. Back then, React was still written with class components! 😄 (For the younger folks reading this - yes, we used to write componentDidMount and this.setState everywhere, and we liked it... sort of.)
IT bootcamps provide an excellent foundation and smooth entry into the profession - ideal for first steps. But once you understand the landscape, you're ready for independent exploration. Later, returning to a bootcamp for new topics feels like overkill. My university education had already given me the necessary skills for finding and analyzing information; I just needed that initial push into the profession.
This realization made me reconsider video courses. Platforms like Udemy - what hadn't worked at the very beginning suddenly became the perfect tool.
Stage 2: Video Tutorials - Quick Immersion (First 2 Years of Experience)
When you're learning a technology for the first time without similar experience to lean on, visual and sequential information delivery with step-by-step explanations is perfect for comprehension. You diligently follow the instructor, implement course projects, add your own touches. Eventually, the information sticks. It's a fast way to master new tools without significant investment.
I consumed countless hours on Udemy and similar platforms. Topics ranged from advanced Node.js concepts in my early days to TypeScript and GraphQL as I gained experience.
But as my knowledge grew, this format suddenly stopped working. I discovered several pain points:
The Illusion of Understanding. Everything makes sense immediately. No need to type the code in your IDE - it all seems simple and obvious. This completely kills effectiveness. Learning must happen through practice, not passive watching. It's not about laziness; it's about blind confidence that "I get it." Result? You've watched a movie you'll forget in two weeks.
Excessive Detail. Information is over-explained for universality - to suit beginners too. Even at 1.5-2x speed, I lacked patience and wanted to skip ahead. When a format irritates you, it's time to find alternatives.
The Same Instructors Everywhere. They'll teach you the entire JavaScript stack. Eventually, the same voices, mannerisms, and presentation styles become grating. Like your favorite song that you overplayed until you can't stand it anymore. No offense to the instructors - they're doing great work. This is about my perception evolving.
The Boredom of Following Along. I wanted to build my own ship, not copy someone else's blueprint. The value of courses evaporated - it became simpler to start a pet project and use documentation with AI to learn through practice.
Lack of Real Assessment. Small automatic quizzes don't test actual skills. There's a desperate need for project assignments with subsequent review or mentoring.
Combined, you outgrow this format - it starts holding you back. The checkbox is ticked, but you haven't actually learned anything substantial.
A perfect example: learning GraphQL. In video courses, everything looks logical and clear - schemas, resolvers, queries. You feel like you've mastered it. But in practice, the real fun begins: Apollo Client caching doesn't work as expected for your specific case, pagination combined with subscriptions breaks cache update logic, and error handling requires deep understanding of the framework's internals. What looks simple in a smooth tutorial flow can take hours of debugging and documentation diving in reality. This gap between "understood in theory" and "made it work in practice" is the format's key limitation.
This format worked perfectly for about two years, then the need for change emerged. It's ideal when you're ready to move independently but aren't yet experienced - you don't have similar patterns in your head, and every detail is absorbed with interest. For experienced developers, the "follow along" format loses its value.
Stage 3: Documentation and Pet Projects - Independent Exploration
If official documentation once seemed dry and non-sequential, failing to provide the big picture, experience flips everything upside down. With a mental model of the stack already formed, associative memory and intuition for common principles help you grasp new tools on the fly. You no longer need hand-holding and step-by-step instructions - documentation and solid Google-fu fill the gaps.
It's fascinating to observe this evolution, when dry official documentation becomes the preferred learning method.
- No fluff - you read exactly what you need, when you need it.
- Realistic learning - you hit real errors, search for real solutions, and remember them because they hurt a little. You stumble, fall, get up, and that struggle makes the knowledge stick.
- Transfer learning - prior patterns help you grasp new tools faster, connecting the dots through intuition and experience.
“Reading documentation without building something is like reading a cookbook without cooking - you might understand the recipe, but you haven’t learned to cook.”
Reading docs alone achieves nothing. The principle stays the same: learn by doing. Build your own ship (a learning pet project) and keep the docs open as your map. For example, this is how I kept my MERN stack skills fresh while working commercially on a different stack. When documentation is thin, bring in other tools selectively - the key is free flight: the ability to find, interpret, and apply information on your own.
This format is harder for beginners - without an existing mental model, documentation can feel confusing and incomplete. But with experience, it’s faster and more “professional” than video tutorials.
The loop: Project → Problem → Docs → Fix → Repeat. That’s how you learn the way you actually work.
This approach also addresses an industry paradox: job postings often demand “2+ years of X” - but how do you get that if no one hires you without it? Self-study through documentation and pet projects isn’t identical to a job, but it’s closer than passively consuming tutorials. It proves you can solve problems in unfamiliar territory.
Rule of thumb: Always start with a project. Let the project drive your reading list.
Stage 4: Courses with Assignments - Structure Plus Freedom
Technologies constantly expand, new tools emerge. The Full-Stack role requires a broad knowledge base, but it's project-specific - you use far from the entire arsenal in any particular job, and logically, the rest fades. Eventually, endless throwaway pet projects also become tiresome and demotivating. You crave a new format.
I recently discovered Full Stack Open from the University of Helsinki, which perfectly suited both reviewing familiar technologies and learning new ones. It worked for me because:
Motivation matters. You can earn official university credits. This requires actually submitting work. There's no direct feedback, but there's the feeling of it - repositories undergo manual review for credit allocation. And it's free.
Build it yourself. Lots of assignments you must implement independently. You can extend them beyond the minimum. The course provides theory and direction, but you own the execution.
It's essentially the same as your own project with documentation, but under university patronage with a structured program. Sometimes it's pleasant to return to roots. As the proverb goes, “Everything new is well-forgotten old.” This mixes different approaches with fresher air.
Through FSO, I covered:
- Backend: Node.js, Express, Supertest, Node testing framework
- Frontend: React, Redux Toolkit, React Query, Vitest, Playwright, Cypress
- Databases: MongoDB, Mongoose, Sequelize, PostgreSQL
- CI/CD: GitHub Actions
- Containers: Docker
- Other: TypeScript, GraphQL
No, the brain can’t memorize every detail of all those technologies (I’ll write about cognitive limits another time). But you can learn to use them to solve real business problems.
Stage 5: Using AI in Learning - A Double-Edged Sword
This is dangerous territory, and I haven't fully formed my boundaries yet, but some things deserve highlighting. AI can either accelerate your growth or completely stall your progress.
Upside: AI is a 24/7 mentor that speeds up work, cuts hours of Googling and Stack Overflow searches, explains complex topics instantly, provides ready solutions.
Downside: if you’re learning something new, pasting AI-generated code directly into your project can rob you of the struggle that actually builds expertise. In learning mode, you need the painful cycles: break → fix → refactor → repeat. That’s where understanding is forged.
Anti-pattern: “Explain this code line by line and I’ll remember it.”
You won’t - if you didn’t fight for it.
Even if AI explains the code in detail, you’ll forget it because you didn’t live through the process. Experience matters far more than passive understanding. Copy-pasting ready solutions during learning is an anti-pattern: you haven’t internalized the mistakes and fixes, so you haven’t built the skill.
If you’re already an experienced developer, leaning on AI isn’t as dangerous - you can read, adjust, and apply code consciously. But when learning new tools, you need to first become a specialist without AI, and only then exploit it as leverage. Otherwise, you risk building an illusion of knowledge, only to discover you can’t solve even simple tasks without the crutch.
One clarification: I’m not against AI in every context. I’m using it right now - not to generate my ideas, but to help polish my words into a readable article. That’s no different from hiring an editor. The thoughts are mine; the tool just helps me present them better. And that's OK, because I’m not aiming to become a professional writer or editor. But in my core craft - software development - the rules are different. That’s the contrast: if it’s your profession, you need to live through the work. If it’s not, outsourcing is just practical.
This article isn’t meant to prescribe rules - I’m just sharing what I’ve observed. But after mentoring in an IT school for 4 years, I’ll risk one piece of advice for beginners: use AI extremely carefully, or better yet, don’t use it at all until you can confidently handle the technology without it. The struggle is what makes the learning real.
What Stayed True Across All Stages
- Active > passive. Editors beat videos. Tickets beat lectures.
- Theory + practice. As the saying goes, "Theory without practice is dead, and practice without reflection is blind."
- Change the method, not the mission. When a method stops working, switch it - don’t stop learning.
“Formats expire. Curiosity doesn’t.”
Conclusion: To Learn Is to Adapt
Looking back, I see a clear evolution: from structured learning with support, to full independence, and finally to a balanced mix of structure and freedom. Each stage was necessary and made perfect sense for its time.
- IT school gave me the foundation and confidence to enter the profession.
- Video courses helped me quickly adopt new technologies in the early years.
- Documentation with pet projects taught me to solve problems in unfamiliar areas by extrapolating existing skills to unknown tools.
- Practice-heavy courses restored motivation and structure without taking away freedom.
- AI became a powerful assistant - useful, but requiring careful guardrails.
The main discovery: your learning format must evolve with you. But one principle never changes - stay an active learner, not a passive viewer.
What format works for you right now?
Share your current stack (courses, routines, tools, rituals) in the comments. Have you noticed your learning style changing over the years? What triggered your transitions between different approaches? I’d love to compare experiences.
Top comments (0)