I've been holding these in for a while. Some of them will make you nod. Some will make you angry. All of them are things I genuinely believe after years of writing code, shipping products, and watching the industry from the inside.
Fair warning: if you're the type who thinks there's only one right way to do things, you might want to close this tab now.
Still here? Cool. Let's go.
1. You Don't Need to Know Algorithms to Be a Good Developer
I said it. Come at me.
Look, I understand why algorithms matter in theory. I get that knowing how a hash map works under the hood makes you a better programmer. But the gap between "understanding algorithms" and "being a productive developer" is way bigger than people admit.
I've shipped real products that make real money. I've worked with teams that build software used by thousands of people. The number of times I've needed to implement a sorting algorithm from scratch? Zero.
What I actually need daily: knowing how to read documentation, debug weird edge cases, structure code so other humans can understand it, and communicate with non-technical people.
The algorithm obsession is driven by Big Tech interviews, not real-world development. Most of us don't work at Google. And that's fine.
The actual hot take: If you spend 3 months grinding LeetCode instead of building a real project, you've optimized for interviews, not for being a good developer. Those are two very different things.
2. Tutorial Hell Is a Myth
"I'm stuck in tutorial hell!" is the most common complaint I see from beginners. But here's the thing: tutorial hell isn't real. What's real is a lack of direction.
Following tutorials is how you learn. That's literally the learning process. You watch someone do something, you copy it, you modify it, you eventually do it yourself. That's not hell. That's education.
The problem isn't tutorials. The problem is following tutorials without a goal. If you're watching your 47th "Build a Todo App with React" video without ever trying to build something of your own, the tutorials aren't the issue. Your approach is.
The fix is simple: Pick a project YOU care about. Use tutorials as reference material when you get stuck on specific parts. Stop watching full courses start to finish and start building things where tutorials fill in the gaps.
Tutorial "hell" is just learning without purpose. Add the purpose and it becomes tutorial school.
3. Side Projects Are Overrated
Before you throw something at me, hear me out.
The tech industry has created this weird culture where your worth as a developer is measured by how many side projects you have. Your GitHub must be green. Your portfolio must be stacked. You need to be coding 24/7 or you're falling behind.
This is toxic garbage.
Side projects are great IF you enjoy them. But if you're forcing yourself to build yet another CRUD app at 10 PM because you think it'll help your career, you're burning yourself out for diminishing returns.
You know what actually helps your career? Being good at your job. Communicating well. Understanding the business side of things. Getting enough sleep so your brain works properly.
I have side projects, sure. But some of my biggest career moves came from being really good at one thing during work hours, not from having 50 repos on GitHub.
The real advice: Build side projects when you're excited about something. Don't build them out of obligation or fear.
4. Most "Clean Code" Advice Is Actually Harmful
Uncle Bob's Clean Code has done more damage to junior developers than any other book in the industry. There, I said it.
Not because the principles are wrong. Some of them are solid. But because juniors read it like gospel and start over-engineering everything.
I've seen PRs where someone turned a 10-line function into 6 files with 3 interfaces and an abstract factory pattern. Why? Because "clean code" said functions should be short and everything should be abstracted.
Here's what actually matters: Can another developer read your code and understand what it does in under 5 minutes? If yes, it's clean enough. If no, refactor. That's the whole framework.
Single responsibility principle taken to the extreme just means your logic is scattered across 47 files and nobody can follow the flow. Sometimes a 50-line function is cleaner than 10 functions of 5 lines each.
5. You Don't Need to Love Coding
This one makes people really uncomfortable.
"Follow your passion" is advice that works for about 5% of the population. The rest of us need a job that pays well, offers flexibility, and doesn't make us miserable. Programming checks all three boxes for a lot of people.
You don't need to dream about code. You don't need to program on weekends. You don't need to have a computer science poster on your wall.
You need to be competent, reliable, and good enough at your job to provide value. That's it.
Some of the best developers I've worked with treat coding as a skilled trade, not a calling. They show up, write solid code, go home, and live their actual lives. They're not on Twitter debating Vim vs VS Code at midnight. And their code is excellent.
The hot take within the hot take: The "you must be passionate" narrative is used by companies to justify overwork. "We only hire passionate people" translates to "we expect you to work evenings and weekends for free."
6. College Degrees Still Matter (But Not Why You Think)
The "you don't need a degree" movement has gone too far in the other direction.
Can you get a dev job without a degree? Absolutely. I've seen it happen many times. But pretending that a CS degree has zero value is dishonest.
A degree gives you:
- A structured learning environment (some people need this)
- A network of peers in the industry
- A credential that opens doors at certain companies
- Exposure to concepts you'd never explore on your own (OS, compilers, distributed systems)
The people saying "degrees are useless" are usually people who already have one, or who are selling you a bootcamp.
My actual take: Skip the degree if you're self-motivated, already have a portfolio, and can handle the job search grind. Get the degree if you want structure, have the time and money, and want to keep certain doors open. Both paths are valid.
7. Frameworks Don't Matter As Much As You Think
The React vs Vue vs Svelte vs Angular debate is the programming equivalent of sports team rivalries. It feels important. It's actually not.
I've seen companies build million-dollar products with jQuery. I've seen startups fail with the most modern tech stack imaginable. The framework is almost never the reason something succeeds or fails.
What matters is: Can you solve the problem? Can you ship it? Can you maintain it?
If you can do those three things with React, great. If you can do them with Vue, also great. If you can do them with vanilla JavaScript and some duct tape, honestly, still great.
Stop arguing about tools and start shipping things. The best framework is the one your team knows well and can be productive with. Period.
8. Remote Work Isn't for Everyone (And That's Okay)
I know this is borderline blasphemy in tech. But remote work has genuine downsides that people don't talk about because it's become a political stance instead of a work preference.
Some people thrive in an office. They need the separation between work and home. They like the casual conversations. They learn better by sitting next to senior devs. They struggle with the isolation.
I personally love remote work. But I've watched friends spiral into depression working from home because they lost all their social structure and couldn't self-motivate without external accountability.
The real opinion: Remote work is a preference, not a moral position. Stop judging people who like going to an office. They're not bootlickers. They just have different needs than you.
The Meta-Opinion
Here's the one that ties them all together: the programming industry has too many opinions and not enough nuance.
Everything is either "the best thing ever" or "completely useless." Either you're passionate or you're a fraud. Either you're grinding 80 hours a week or you're lazy.
Real life is messy. Real careers are messy. What works for one person is terrible for another. The sooner you stop trying to follow someone else's playbook and start figuring out your own, the better off you'll be.
If you made it this far without rage-quitting, we'd probably get along. I share more honest takes about dev life and career stuff here:
Telegram: t.me/SwiftUIDaily - no fluff, just real advice
Boosty: boosty.to/swiftuidev - career kits, templates, and tools for developers
Which opinion made you the most angry? Drop it in the comments. I can take it.
Top comments (0)