Skip to content
TASIMA HAPAZARI
WritingLearning

What a CS degree did and did not teach me

Three years at UCT gave me the theory and none of the deployment. A fair account of what transferred to real work and what I had to learn on the job.

3 min read

This post's shape: Lead 62 words, 01 146 words, 02 129 words, 03 122 words, 04 119 words.

University teaches you how software works. It doesn't really teach you how software gets made - by people, for other people, inside organisations that already have opinions about how it should be done.

So this isn't a complaint about the degree. It's an honest split between what carried over into real work and what I had to learn once I got there.

01

Specs, then a real brief

For most of the degree, the work arrived pre-decided. We received specs, similar to what a junior dev would get: here's the problem, here's the shape of the answer, build it. That's a good way to learn the theory. It's not much practice at deciding what to build.

To be fair, my final year was the first time I got to experience what true development and product engineering looks like - given a problem description and a rough stack as guidance, and creating a full application from that. The only strict requirement was Kotlin for native Android development, especially since we were working with a lot of low-level components.

Working out what the application should actually be was suddenly part of the work, not something handed down with the brief. That project was the closest the degree came to the job.

02

Where it left gaps

Where university didn't prep me was:

  1. 01Dealing with clients. A spec never changes its mind halfway through. A client can, and usually for a good reason you only hear about later.
  2. 02Corporate strategy and bureaucracy. Who has to sign off, which team owns which system, and why the technically obvious answer is sometimes not the one that ships.
  3. 03Making choices across the full stack that align with infrastructure in place. In assignments you pick the stack. At work, the stack has usually been picked for you, and a good choice is one that fits what's already running.

None of these are really technical gaps. They're the parts of the job that sit around the code, and they're where most of my learning has happened since.

03

Translation is the job

Over the past couple of months, I realised one of the best skills a product engineer can have is being able to translate requirements from a technical perspective into simple layman terms - and back again. Without that, you're constantly making feature and stack changes simply because things are getting lost in translation.

It works in both directions. A client describes what they want in terms of what they see; the build needs it in terms of data, states and edge cases. If either side of that conversation is fuzzy, the gap gets filled with assumptions, and assumptions are what you end up rebuilding.

Nothing in my degree graded that skill. It's probably the one I use most.

04

Not everything needs AI

Another thing is tempering requirements during the gathering phase, especially when it comes to things like integrating AI. Admittedly, AI is amazing. But not only do you need the infrastructure to support it - even though the sky is the limit, not everything requires AI.

Simply "Add AI to it" isn't a one-size-fits-all solution.

(Also, low-key that phrase is a developer's nightmare rn.)

Tempering doesn't mean saying no to the idea. It means asking what problem the AI is meant to solve, whether something simpler already solves it, and whether the infrastructure underneath can carry it. That conversation is a translation problem too, which is probably why it's the skill I keep coming back to.