Having a CS Degree: Degreeitis or Reality?

The eternal debate in tech. Everyone has a strong opinion about whether you need a CS degree or not. There are those who swear you can’t be a real developer without it, and there are those who say it’s a waste of time and money.

I was on both sides. I started college, attended classes, got good grades, and then I paused it. Today I have a perspective that I think is worth sharing.

This is my real story. No filters.

How it all started: CS mods and WoW servers

At 14, I was already coding. Not because someone taught me — I learned alone, throwing code and breaking things until they worked.

My first “serious project” was creating mods for Counter-Strike 1.6 using Allied Modders (AMX Mod). It was a huge community, with scattered documentation, forums full of ancient threads, and no one to explain things clearly. You had to search, experiment, break things, and figure out why something didn’t work.

Later I moved to World of Warcraft. Not just playing it — I ran servers. I cloned the Trinity Core emulator and started modifying it. Created bosses with simple mechanics, custom quests, world events. All in C++.

What did I learn from that? A lot. I learned to read other people’s code, to debug problems that had no stack trace, to think in logical flows, and not to be afraid of tackling big and complex things. I learned that when something doesn’t work, it’s probably because you assumed something that wasn’t true.

The summer before college: CS50, C, and the surprise

When I decided I was going to study CS, I took the summer before seriously. I didn’t want to arrive fresh.

I started with Harvard’s CS50 — David Malan’s course that’s available free on edX. That course planted in my head the idea that programming wasn’t just about writing code, but about thinking algorithmically. Solving problems. Breaking them into small parts.

Then I moved on to C. Learned pointers, memory management, basic data structures. All the frustration of segmentation faults taught me more than any theoretical slide ever could.

When college started, I thought the biggest challenge would be programming. I had studied all summer, I already knew C, I already understood basic concepts.

I was wrong.

The real enemy: Physics, Math, and Linear Algebra

The problem wasn’t programming. The problem was the things that programming uses as a foundation.

Physics. That subject that makes you sweat because you have to understand forces, fields, energy — and then translate all that into formulas that can be solved. It wasn’t hard because it was complicated. It was hard because it required abstract thinking, working with models you can’t directly see.

Mathematics. Calculus, sequences, integrals. Everything that seemed abstract and disconnected from reality made sense when you connected it to concrete problems. But it took time.

Linear Algebra. Vector spaces, matrices, transformations. This surprised me the most — I thought it was going to be decorative, and it turns out it’s the foundation of everything: machine learning, graphics, signals, complex systems of equations. Everything goes back to vector spaces.

Oddly, I liked those subjects. Not because they were easy, but because they challenged me in a way programming didn’t. Programming was comfortable. Math was hard.

First year: when I realized I could learn from both sides

During my first year of college, while the courses weren’t that demanding yet, I kept studying on my own. Not because college wasn’t helping me — but because I wanted more.

I dove into webdev. Started with frontend: HTML, CSS, JavaScript. Then moved to React. Watched tutorials, read documentation, built simple projects. The feedback loop was fast: change something, see the result, fix, repeat.

Then I ventured into backend. Node.js, then TypeScript. Built simple APIs, integrated databases, learned basic auth. Not production-ready, but enough to understand how things worked.

When the summer after first year came, I made a decision: I was going to go all in.

The summer of immersion: data structures, algorithms, and real practice

That summer wasn’t about rest. It was about work.

I got a data structures book — arrays, linked lists, trees, graphs, hashes. Implemented everything from scratch in Go and C. Not just reading how they worked, but writing them, understanding the trade-offs, seeing why a BST was better for search but worse for insertion.

Then I got into algorithms. Sorting, searching, graphs, dynamic programming. Solved dozens of problems on LeetCode and HackerRank. At first it was slow, frustrating. Then I started seeing the patterns: two pointers, sliding window, divide and conquer. The brain rewired itself.

Parallel to that, I put everything into practice. I didn’t just want theory — I wanted to build things.

I built a project with Next.js and TypeScript. Consumed an API, displayed data, had pages, routing, styling. Then migrated the same idea to Go: a backend with Gin, REST endpoints, basic testing. Same concepts, different languages, different philosophies.

That summer I got my first job.

The first job: when reality hit differently

It wasn’t a dream job. It was a junior dev at a small company that built internal software. But it was what I needed: real context.

At work I learned things college doesn’t directly teach you:

How to work in a team with legacy code
How to read vague specifications and turn them into concrete features
How to debug in production (not in development, in production)
How to talk to stakeholders who don’t understand code

I also learned something deeper: when you work on something real, the motivation changes. It was no longer “I want to learn this because it’s in the syllabus”. It was “I need to solve this problem so the business keeps running”.

Accelerated learning.

The moment that changed everything: pausing college

After my second year of college and already working, I made a decision that took me a year to make.

I was going to pause college for one year.

It wasn’t an easy decision. I was doing well with grades, had good relationships with professors, was on track to do fine. But there was something bothering me: I felt like I learned more locked in my room 4 hours studying on my own than 4 hours with a professor lecturing.

It’s not that the professors were bad. It’s that the pace of a class is defined by the average of the course. And I wasn’t average. I wanted to go faster.

So I decided to test it: how far could I get on my own in one year?

The year of transformation: DevOps, architectures, and new worlds

That year changed my life.

First, I got transferred to the DevOps team. Not because it was my original goal, but because there was a gap and I was eager to learn new things. I accepted.

What I learned that year:

AWS: EC2, S3, Lambda, RDS, CloudFront, Route 53. All the infrastructure as a service.
Kubernetes: pods, services, deployments, ingress, helm charts. The complexity of orchestrating containers in production.
Terraform: infrastructure as code. Define cloud resources in files you can version and reuse.
Best practices: CI/CD pipelines, code reviews, testing, observability, alerting.
Go in depth: not just writing code, but writing idiomatic code. Concurrency with goroutines and channels. gRPC for service-to-service communication. The minimalism of the language.
Complex architectures: microservices, event-driven systems, CQRS, hexagonal architecture. Patterns I had only read about in blogs and now saw implemented in production.

I also started taking courses I had always wanted to take:

Bioinformatics: the intersection of biology and computation. Algorithms for DNA analysis, sequence clustering, machine learning applied to genomics.
Embedded systems: Arduino, Raspberry Pi, C programming for microcontrollers. The physical world interacting with code.
Framework experimentation: Rust for some systems programming, Elixir out of curiosity for functional programming, Python for data science.

The eruption of AI: when everything changed

In the middle of all this, AI exploded.

At first I didn’t pay much attention. Another hype, another buzzword. But when it started affecting my daily work, I opened my eyes.

The first flows were simple: embeddings for semantic search, RAG for chatbots that could answer questions about internal documentation, basic code generation with completions.

Everything was experimental. Functional, but experimental.

Then Claude Code appeared.

Claude Code: the game changer

When Anthropic released Claude Code, I tried it out of curiosity. I didn’t expect much — other times I had used AI tools for code and they were mediocre.

But this was different.

Claude Code wasn’t a doped autocomplete. It was an agent that could reason about code, understand context, make consistent changes, and hold conversations about architecture and design.

Within a week, my way of working fundamentally changed.

It was no longer “I write code and then improve it”. It was “I describe what I want and the model helps me think through the solution, implement the code, and review that it works”.

The bottleneck stopped being writing code. The bottleneck became understanding problems and designing solutions.

“It doesn’t matter how you code it anymore. It matters how you think.”

The ideal world for the self-taught

Today, after all this path, I live in the world I always wanted.

I can dream an idea on a Monday and have a working prototype the same day. I can tackle problems that would have taken me weeks before — now it takes me hours or days. Not because I’m smarter, but because I have better tools and more practice at thinking through problems.

AI didn’t replace my ability to learn. It amplified it.

I can research any new topic in hours instead of weeks. I can ask a model to explain complex concepts and give me concrete examples. I can let it do the boilerplate while I focus on the interesting stuff.

So what’s a degree for?

I’m not saying degrees are useless. Degrees give you:

Solid fundamentals: data structures, algorithms, computation theory. Things that take time to learn on your own and are easier when you have a structured curriculum.
Credibility: there are still places that filter by degrees. I don’t like it, but it exists.
Networking: contacts, access to internships, opportunities you won’t find on Google.

But I’m also saying degrees aren’t the only path. And for many, they’re not the best path.

What shaped me wasn’t college. It was:

The obsessive curiosity to understand how things work
The hours locked away learning new things
The willingness to take risks (pausing college, switching teams, learning things outside my comfort zone)
The intrinsic motivation to solve interesting problems

The message for the one who’s starting

If you’re reading this and deciding whether to go to college or not, or if you’re already in and thinking about dropping out, consider this:

There’s no right answer. There are different paths and different starting points.

But if you decide to go the self-taught route — or even if you decide to pause like I did — you need to understand something: discipline has to come from you. No one will push you. No one will tell you what to study tomorrow. You have to build your own curriculum, set your own goals, and maintain motivation when everything gets hard.

And today, more than ever, you have tools that make this easier. LLMs, intelligent code editors, online communities, free courses from top universities. Access to knowledge has never been more democratized.

The conclusion

Degrees are useful. But they’re not necessary.

And for the one who’s willing to learn for a lifetime, to experiment, to take risks, and to build things — today is the best time in history to be self-taught.

I don’t regret starting college. It gave me fundamentals I use every day.

But what made me a developer wasn’t the diploma. It was curiosity, hours studying alone, and the willingness to never stop learning.

That’s the only thing that really matters.

korz.sh — pingedbrain/korz Currently exploring the world of AI and automation