Here’s my spicy take for the day: if you’re advising a high school senior on what to study, stop defaulting to computer science.
Get a business degree. Minor in CS.
I know that sounds backwards. I’ve spent 20+ years building software, leading dev teams, and turning around broken engineering organizations. The most important skill in this industry has never been writing code. It is understanding the problem you’re solving.
AI just made that gap a canyon.
Most Companies Don’t Do Computer Science
There are two kinds of companies: companies that use software to solve business problems, and companies where software is the business problem. Understanding which one you work at, and your role in it, is one of the most important things you can figure out early in your career.
Computer science is algorithms, computational theory, data structures, operating systems, compiler design. It’s the deep math and logic behind how computers actually work. That’s the second kind of company, where software itself is the product and the problem domain.
That matters if you’re working at NVIDIA on GPU architectures. It matters at Apple and Microsoft building operating systems. It matters in the narrow slice of FAANG/MANGO where you’re designing distributed systems at planet-scale.
But the overwhelming majority of companies are the first kind. They use software to solve business problems. Almost nobody in academia wants to say what that means out loud: most software jobs have very little to do with computer science.
That SaaS platform managing insurance claims? Not computer science. The logistics app optimizing delivery routes? Closer, but the hard part usually is not the routing algorithm. It is understanding the constraints of a driver’s actual day. The internal tool tracking inventory across warehouses? That is a business problem expressed through software.
The vast majority of this industry is translating business needs into working software. CS programs spend almost no time teaching that translation.
What CS Programs Optimize For
A four-year CS degree optimizes for understanding how computers work. That is valuable. Algorithms, data structures, computational theory, operating systems, and compiler concepts all help you understand the machine at a deeper level.
But most software jobs do not ask you to write a compiler or even understand how one works. They ask you to understand a business process, identify the user need, decompose the work, make trade-offs, and turn all of that into software the organization can actually use.
That is where the gap shows up.
A CS program optimizes for technical correctness inside the machine. It may give you one semester of software engineering. It may ask you to write applications whose main purpose is proving that your code compiles. It may teach you how to reason about runtime complexity. It usually spends very little time teaching you how to sit with non-technical stakeholders, refine ambiguous requirements, prioritize competing needs, explain trade-offs in business language, or understand the financial and operational context behind a technical decision.
Most software careers optimize for something else: judgment inside a business system. You need enough technical knowledge to make good engineering decisions. You also need enough business knowledge to know which decisions matter.
Recently, I reviewed code from a mid-level developer for a process that runs every 15 minutes. The process pulls a set of records, then performs three lookups and two updates for each record. Because of timing constraints, the batch size needed to stay around 150 records per run.
The code was correct. It was functional. It would perform within reasonable bounds. But it treated each record as the unit of work.
Once we looked at the process differently, the shape of the solution changed. The three lookups could be done for all 150 records in batches, and those batches could run in parallel. The update payloads could be created in parallel. The API updates could then be queued and run in parallel or in controlled batches, depending on API rate limits and how much pressure we wanted to put on the downstream system.
That is not really a compiler problem. It is a process-shape problem. It requires technical knowledge, but the important move is understanding the workflow, the constraints, the throughput, and where work can safely happen at the same time.
I’ve led teams where brilliant CS graduates couldn’t write a story that made sense to anyone but themselves. Not because they lacked intelligence. They could solve the technical problem in front of them. What they could not do yet was translate the business problem into a clear, testable unit of work.
Nobody had taught them to think from the business side of the table.
AI Changes the Equation Permanently
This is where it gets uncomfortable for CS purists.
AI can write code. Good code. It’s getting better every quarter. In my own work, I have found that AI with proper guardrails can write better, cleaner code faster than nearly anyone I know. The gap between what an AI can generate and what a junior developer produces is shrinking to zero for most standard application development.
What AI cannot do is carry your business context the way a human can.
I frame this for people as a context problem. Yes, modern AI systems can have enormous context windows. Some can hold a million tokens during a session. Humans have a much larger context window that we call long-term memory.
The business process does not live by itself. It sits inside the people, the history, the incentives, the politics, the customer expectations, the operational habits, and the ethos of the company. All of those subtle details shape good decisions. They do not fit cleanly into a prompt, and they cannot be reloaded perfectly every time an AI session starts.
There are products trying to solve this. Some are useful. None have solved the full problem.
The developers who will thrive in an AI-native world aren’t the ones who understand code the deepest. They’re the ones who understand the problem the deepest.
The person who understands the business can frame the problem correctly. That framing is what AI needs to build the requirements and then the solution. The entire chain from problem to production starts with someone who can articulate what needs to happen and why. AI is increasingly strong at the how.
A person who understands supply chain logistics and knows how to work with AI will often get better results than a stronger coder who has never talked to a customer. That is not hypothetical. That is the trajectory we’re already on.
The Developers I Turn Around Aren’t Missing CS Knowledge
Here’s where this gets personal.
I coach engineering teams for a living. I walk into organizations where sprint completion rates are in the 20-30% range, developers are working in isolation, and nothing ships on time. I’ve turned those teams into high performers: 85%+ completion, double the output, predictable delivery.
The problem is never that the developers don’t understand enough computer science.
It’s that the system around them doesn’t connect the work to the business. Stories are poorly defined because nobody taught them to think about the user’s actual problem. Sprints fail because the work was scoped by someone who understood the code but not the business constraint. Features get built and sit in UAT for months because developers shipped what was specified without understanding what was needed.
Every single time, the turnaround involves building a bridge between the technical work and the business context. The teams that cross that bridge fastest are the ones with developers who can think in both languages.
A CS degree doesn’t teach that. A business education does.
What I’d Actually Recommend
If I were advising a student starting college today, I would tell them to major in business and minor in computer science. Management information systems, operations management, and general business administration are all strong paths. The CS minor gives enough foundation to understand what AI is producing, read code critically, and spot structural problems. The business major teaches why the software exists in the first place.
If the student is already in a CS program, I would tell them to get a serious business minor at minimum. Take accounting, operations, project management, and strategy. Learn how a P&L works. Learn what executives actually care about. Technical skill may get the first job. Business fluency compounds over the rest of the career.
For hiring managers, the same principle applies from the other side. Stop requiring CS degrees for roles that are really about business problem-solving. The best developer on the team might be the person who worked in the industry for five years before learning to code. They already understand the domain. The code part is increasingly the easy part.
The Exception
I’ll be honest about where this breaks down.
If you want to work on GPU compilers at NVIDIA, you need a CS degree. Probably a master’s. If you want to build operating systems at Microsoft or work on core infrastructure at Google, computer science is the right path. The same applies if you’re looking to work at Anthropic, OpenAI, or any of the myriad AI model startups.
But those jobs represent a tiny fraction of the industry. If you’re one of the rare people drawn to that kind of work, you already know it. You were the kid who wanted to understand how the computer itself works, not just what it can do.
For everyone else, and that’s most of you, the computer is a tool. Learn enough about the tool to use it well. Spend the rest of your education learning about the problems it can solve.
This Isn’t Hypothetical Advice
I’m not theorizing. I lived this.
I started college as an Asian Studies major. Switched to Graphic Design. Dropped out and spent most of my career without a degree at all. What I did do, during those years, was take every business class I could find and read everything I could get my hands on: management, operations, strategy, finance. I gave myself the business education I knew I was missing.
I finally finished my business degree in 2005. Not a CS degree. A business degree. I’ve spent the 20 years since leading software teams, turning around broken engineering organizations, and building systems that actually deliver.
The CS knowledge I needed, I picked up on the job. The business knowledge is what made me effective.
I gave this exact advice last month to a college freshman who’s currently a CS major. He’s the friend of my stepson, a smart kid who likes technology and figured CS was the obvious path.
I told him: at the very least, pick up a strong business minor. Better yet, consider flipping it. The CS fundamentals he needs to collaborate with AI and read code critically would fit in a minor. The business knowledge he needs to build a real career (understanding how organizations work, how decisions get made, how to translate between technical and non-technical stakeholders) is a full major’s worth of education.
The world does not need more people whose only value is writing code. AI is increasingly handling that. The world needs people who understand what code should do, and can prove it matters to the business.
That’s a business education.