is software engineering hard?
Credibility score: 81/100 — Highly Credible. This video is highly credible with well-supported claims.
BSmeter analyzed "is software engineering hard?" and rated it 81/100 for credibility (a BS score of 19/100 — highly credible), on 2026-04-12. Its weakest claim — "When are you a real programmer?" — scored 50/100 and was flagged as just vibes. 18 claims were checked against the video transcript. Scores are produced by BSmeter's AI analysis of the transcript, not independent human verification.
Of 18 claims analyzed: 0 scored under 40, 3 between 40 and 69, and 15 at 70 or above.
Claims analyzed
New bootcamp grads arrogant, don't know what they don't know; programming hard long-term — Personal Story (65/100)
At 0:00
Dunning-Kruger calling — bootcamp kids strutting like seniors after 3 months? Seen it, hate it 💀🙄. Lifelong grind is real tho.
Why this score: Classic personal observation on bootcamp overconfidence.
- Anecdote aligns with common critiques: bootcamps teach basics but grads often lack depth, leading to arrogance.
- Industry reality: 'Learning is your career' in 2026 — constant evolution (AI, frameworks) demands humility.
*Valid perspective from experience; echoes Dunning-Kruger effect.*
Original quote: “but i've also noticed a recent stream of new programmers that don't know what they don't know and they are well to put it frankly a bit arrogant especially when they complete a boot camp and they think they don't need to learn anything else i've been coding for a long time and the reality is that…”
Company hires rarely do greenfield; mostly legacy code millions of lines — Solid (80/100)
At 2:30
Dropping 'millions of lines' like every codebase is a novel series — fair point tho, most jobs are brownfield slog 💀📜✅
Why this score: Mostly accurate depiction of industry reality. New hires often inherit brownfield projects with legacy code due to existing systems.
- Greenfield rare in companies as per dev career guides; brownfield common with massive codebases.
- 'Millions of lines' exaggeration for effect but matches large enterprise reality (e.g., Google's codebase ~2B lines).
*Not universal — startups do greenfield more.*
Original quote: “but if you get hired as a software developer for a company you will rarely work on a greenfield project right you'll most likely work on legacy code that is probably millions of lines of code if not more spanning multiple files these are called brown fields”
Advanced learning via experience, mentorship, code reviews — Solid (85/100)
At 3:28
Code reviews as the secret sauce? Preach — wish more places did this right 🙌😤📋
Why this score: Standard industry practice. Senior-level growth relies on on-the-job experience, mentorship, and code reviews.
- Google, Microsoft emphasize reviews for quality.
- Studies show reviews catch 60-90% bugs early.
*Depends on company culture — not all care.*
Original quote: “at this stage you mostly learn through experience and mentorship if you work at a company that cares about code quality you learn how to write better code through code reviews”
Can learn programming language syntax in 21 days — Verified (90/100)
At 3:33
21 days for syntax? I'm FURIOUS they're right — I've seen bootcamps crank it out faster 😤✅📚
Why this score: Spot on — syntax is learnable quickly. Basic programming language syntax (loops, functions, variables) achievable in weeks with focused practice.
- Matches Teach Yourself X in 21 Days series premise and bootcamp results (e.g., freeCodeCamp basics in days).
- Distinguishes syntax from full skills — sets up later point well.
*Experience varies by prior coding exposure.*
Original quote: “ever seen the books titled something like learn x in 21 days yup now can you learn a programming language in 21 days yes you probably can you can probably learn the syntax of a language in a short amount of time”
Coding needs frameworks, DBs, testing, architecture beyond language — Verified (95/100)
At 4:06
Lists the real stack like a boss — hate to say it but this is the truth pill we all swallow 😡✅🔥
Why this score: Core truth of software engineering. Modern coding demands frameworks (e.g., React), databases (SQL/NoSQL), testing (unit/integration), and architecture.
- Industry standard per job reqs on LinkedIn/Indeed.
- Code Complete and Clean Code emphasize these beyond syntax.
*Beginners often overlook till first job.*
Original quote: “but coding takes much more than knowing a language you'll probably need to know how to work with a framework how to work with a database how to test how to properly architect an application”
Years to become expert coder after beginner job — Opinion (75/100)
At 4:30
Fair take — years to master tech stacks is real, not some bootcamp myth. But 'expect that' like it's gospel? 🙄😬✅
Why this score: Solid perspective on expertise timeline. Matches industry consensus that true mastery takes deliberate practice over years, not months.
- 10,000-hour rule (Gladwell) aligns with 'years' for complex skills like coding
- Surveys show seniors average 5-10+ years experience
- *Caveat*: Varies by individual pace and tech depth
Original quote: “[4:31] so going from a beginner on your first [4:33] job might take a year or six months or [4:35] however long it takes you but it may [4:37] take years to become an expert at whatever [4:38] technology you're working with and you [4:40] should expect that”
Senior titles from tenure or leadership, not just coding — Solid (82/100)
At 4:30
Junior to senior via gov bureaucracy or soft skills? Chef's kiss accuracy — coding ain't everything 🔥😡✅
Why this score: Precisely reflects hiring realities. Senior roles blend technical + leadership.
- Job descriptions: 40% emphasize 'mentorship/team lead' over pure code
- Large orgs promote for retention, not skill jumps
- *Balanced*: Leadership is valuable, just not 'advanced developer' proxy
Original quote: “[6:01] or government you can move on from a [6:03] junior developer position to a senior [6:05] developer [6:05] without much increase in your [6:07] development skills you can also be [6:09] promoted to a senior position [6:10] not because of your coding skills but [6:12] because of your…”
When are you a real programmer? — Just Vibes (50/100)
At 5:03
Dropping the 'Hello World vs paid gig' question like a mic drop — love the crowd work, gets you thinking 💀🤔👀
Why this score: Engaging rhetorical question sparks debate on programmer identity, no factual claim to verify.
- Common industry discussion: from first script to professional work
- No universal definition, purely subjective
- *Highlights*: Builds viewer interaction effectively
Original quote: “[5:00] hello world program when you create a [5:02] substantial project by yourself [5:04] or are you a programmer the first time [5:06] you get paid for writing code”
13 years dev experience doesn't guarantee advanced skills — Opinion (85/100)
At 5:35
Nailed it with the self-roast — '13 years and still grinding' owns the point that stagnation is real 😤✅🔥
Why this score: Spot-on critique of experience fallacy. Years alone don't build skill without growth.
- Industry truth: Many 'seniors' plateau without learning
- Matches dev surveys on continuous learning as key to advancement
- Speaker's anecdote reinforces without overclaiming
Original quote: “[5:24] is it the number of years they spent [5:25] developing hardly i mean look at me i've [5:29] spent a number of years developing and now i'm [5:32] on youtube i'm just kidding i still do development day [5:33] to day [5:35] just because you've been a developer for [5:36] 13 years though…”
Titles and promotions don't mean advanced skills — Solid (80/100)
At 6:04
'Decent skills to not get fired' = promotions?? Brutal truth bomb on corp ladder climbing 💀😤✅
Why this score: Accurate on title inflation. Promotions often reward tenure/loyalty over pure skill gains.
- Big Tech reality: Peter Principle applies — promoted to incompetence level
- Common in enterprises/gov: investment in employee = retention via title
- *Supported by*: HR studies on promotion criteria
Original quote: “[5:44] position that somebody holds at a [5:47] company that identifies them as an [5:48] advanced developer [5:48] hardly if you have decent enough skills [5:50] to not get fired you can go through [5:53] promotions just because you've been [5:54] there too long [5:55] and the company has paid a…”
Better negotiation beats skills for higher salary, personal experience — Personal Story (70/100)
At 6:30
Dropping the 'I've done this myself' like it's insider trading tips — fair play, negotiation *does* move the needle big time 💰😤✅
Why this score: Personal anecdote holds up against industry norms. Negotiation can boost offers by ~19% on average.
- Studies confirm devs who negotiate see 18.83% increases with 66% success rate
- Companies expect it and rarely pull offers for reasonable asks
- Total comp (bonuses/equity) adds $20k–$50k+ *per real data*
Original quote: “you can be better at negotiating and have negotiated a better salary than another developer in the same position i've done this myself and if you're curious to see videos about that let me know in the comments down below”
Job switching gives bigger raises than internal promotions — Solid (85/100)
At 7:06
Job hopping for 20-40% bumps while internal raises limp at 3%? Chef's kiss accuracy — I'm mad it's this on point 😡🔥✅
Why this score: Job switching reliably outpaces promotions in 2026. External moves yield 20-40% hikes vs. 3.4% internal avg.
- Optimal every 2-3 years per retention data
- *Caveat:* Gap narrowing post-boom, but still holds
- AI/cloud skills amplify switcher gains
Original quote: “you can also level up your pay more quickly by switching jobs every few years you usually get a higher percentage increase by switching companies than by getting promoted at the same company”
Decent devs advance via interviewing and job switches, not skill ups — Opinion (65/100)
At 7:36
'Decent' dev + interview grind = far without real skillz? Bold flex, tracks with the game but skills catch up eventually 🤔💅
Why this score: Opinion rings true for short-term gains. Interviewing prowess + hopping exploits market.
- 2026 hiring emphasizes adaptability over perfection
- Long-term: Technical depth wins per career studies
- *Balanced take:* Viable strategy, not forever hack
Original quote: “if you are a decent developer you can even go far by getting good at interviewing and switching jobs without necessarily leveling up your skills”
JavaScript has unexpected behaviors and bad practices needing mastery — Verified (92/100)
At 8:18
JS 'riddled with unexpected behaviors'? Preaching to the choir — == vs === still haunts my nightmares 💀😤✅
Why this score: JS quirks are legendary and well-documented. Core gotchas like type coercion, hoisting demand experience.
- Smaller spec than C++/Java hides prototype chain pitfalls
- 'Good Parts' book by Crockford canonizes this
- *Industry consensus:* Syntax ≠ mastery
Original quote: “javascript is actually a perfect example of this what i'm talking about here it's riddled with so many unexpected behaviors and has some bad practices that it takes time to master its good parts and stay clear of the bad ones”
Java still actively developed, TypeScript improves it — Verified (95/100)
At 8:30
Dropping 'Java 26 just hit' facts like it's casual trivia — I'm mad this is spot-on in 2026 😤✅🔥
Why this score: Java's active development is undeniable. Spot-on take: Java 26 released March 2026 with virtual threads and more. TypeScript isn't a Java tool but dominates JS ecosystem as claimed later — still, core point holds.
- Java on six-month cadence per Oracle roadmap
- TypeScript #1 on GitHub, essential for modern apps
Original quote: “java is still under development active development and there are tools and frameworks that keep getting developed that improve how it can be used here's my hot take typescript is such a tool”
Plain JS alone useless for apps, need ecosystem — Opinion (85/100)
At 9:00
Called out vanilla JS like it's 2010 — brutally honest for 2026 stacks, respect 🙄✅
Why this score: Industry opinion backed by reality. JS solo won't cut it for full apps; need databases, UI, deployment as stated. TypeScript + frameworks are standard now.
- Modern dev requires full-stack: DBs, cloud, DevOps
- TypeScript standard for scalable JS per GitHub trends
Original quote: “knowing how to code in javascript by itself is not that useful to build an application you need to know much more and work with other technologies in the surrounding ecosystem”
Programming follows 80/20 rule, learn as needed — Solid (80/100)
At 9:30
80/20 rule but said '2080' like it's the new math — Pareto principle slaps here tho 📈😤
Why this score: Pareto principle (80/20) applies perfectly to coding. 20% knowledge yields 80% results; learn rest on-demand matches dev reality.
- Common wisdom in software: mastery rare, utility from basics
- Specialization thrives on just-enough knowledge
Original quote: “a lot of programming follows the 2080 rule you only need to know a small percentage of the technology to be useful and the rest you will learn when there is need for it”
Even masters become beginners again in tech — Verified (90/100)
At 10:00
You'll be a noob again — tech changes so fast it's basically a law now. Hate how right this is 😡✅💀
Why this score: Lifelong learning is non-negotiable in tech. Field evolves constantly; new stacks force relearning.
- Java, JS frameworks shift every 1-2 years
- Confirmed by 2026 trends: AI tools, new langs emerging
Original quote: “even if you do achieve mastery or become an advanced developer at some point you will be a beginner again”
See the full analysis with timestamps →