In Stop Telling Kids to Major in Computer Science, I recommended that students interested in most software development careers consider a business degree with a computer science minor. My reasoning was simple: much of our industry builds applications to solve business problems, so developers need to understand both the business and the software.
Some careers require deeper computer science. Building hardware drivers, operating systems, and compilers calls for knowledge beyond what I’m proposing for most application developers. AI is changing those fields, too. Work that once demanded specialized implementation skills is becoming more accessible, even as understanding and judgment remain essential.
I still think the combination of business and computer science provides a useful foundation. But what if a student didn’t have to assemble that education from a major and a minor?
What would a degree designed specifically for the AI-native software developer look like?
A Different Kind of Graduate for a Different World
I would build a four-year degree for the AI-native software developer. Its graduates would understand how organizations work, how applications are built, and how to connect the two. They would learn to speak with the people who use software and the people who build and operate it. And they would learn how to use AI to bring it all together.
The goal is to create a capable generalist with a foundation to build on throughout a career. Alongside the courses below, students would take general education and electives that broaden their perspective.
The graduate I have in mind can sit with a user, understand the work that person is trying to do, and ask enough questions to identify the real problem. They can model the information involved, design a practical solution, use AI to help implement it, and establish whether the result works.
They also know where their knowledge ends. Understanding how applications communicate does not make someone a network engineer. Recognizing a security risk does not make them a security specialist. It does help them investigate a problem, explain what they found, and bring in the right expertise.
This degree serves students whose primary interest is building software that solves organizational and customer problems.
First Year: Learn the Pieces
The first year builds a working understanding of the pieces that appear in an ordinary business application. Students write small programs, create a basic interactive website, and design databases. They learn about organizations at the same time because software has a purpose outside the code editor.
I believe there is value in having students do some of this work by hand. Learn programming fundamentals. Build classes and objects. Write HTML, CSS, and JavaScript. Create a relational schema and query it. Model the same problem using documents, then explain the tradeoffs. They do not need to memorize every API, but they should be able to follow execution, find a defect, and make a targeted correction.
AI can explain a concept or help a student work through a confusing result. Some assessments should still require the student to demonstrate the skill independently. That foundation gives them a way to question generated work later.
Second Year: Connect the Pieces
The second year connects those foundations. Functional programming introduces another way to organize behavior. Data structures and practical algorithms teach students to reason about cost and scale. Software design introduces clean architecture, SOLID principles, and patterns as tools for making systems easier to understand and change.
Networking should follow a request through an application: DNS, HTTP, TLS, APIs, ports, proxies, timeouts, and failures. Graduates will not be network engineers. They should understand how their applications communicate and know where to start when they do not.
Requirements discovery deserves the same attention. Students should interview users, observe a process, identify conflicting needs, and distinguish a requested feature from the problem behind it. AI can help organize notes and expose gaps. The student remains responsible for understanding the people and confirming the intended outcome.
Third Year: Design and Deliver Systems
System design should be a two-part sequence. The first course focuses on the boundaries inside an application: presentation, business logic, data access, interfaces, and dependencies. Students design a system against a business need and revisit those decisions when the requirements change.
The second course expands to connected systems: APIs, asynchronous work, integrations, availability, and recovery. What happens when a dependency is slow? What happens when one part of an operation succeeds and another fails? Those questions are easier to answer when students have already learned how the individual components work.
Testing, security, and DevOps belong in the core because a functioning solution must survive use and change. AI foundations belongs there too. Students should understand training and inference at a practical level, how context affects output, and why a confident answer still requires evaluation. Business law gives them a foundation in contracts, intellectual property, privacy, licensing, and when to involve counsel.
Fourth Year: Apply Judgment Across the System
The final year brings the disciplines together. Students build AI-enabled applications and agents, then learn how to evaluate both the work an agent produces and the behavior of an AI-powered application. They need to understand a particularly dangerous failure: an agent can generate an implementation and tests that share the same mistaken assumption.
Production troubleshooting should require students to move across the system. Recently, I investigated a web application that failed intermittently. With AI assisting, I directed the investigation from the user-facing error through Nginx messages and CloudWatch logs, then into live PHP worker activity and database lock information. The workers were waiting behind queries from another application that ran for more than four minutes.
That is the kind of problem a graduate should be prepared to investigate. The visible failure appeared in one application. Understanding it required following evidence through the infrastructure and into a shared database. An AI agent helped examine the evidence; directing the investigation and deciding what the evidence meant remained my responsibility.
The Capstone
The capstone should span the academic year and begin with a stakeholder who has a business problem, not a finished specification. The team interviews users, studies the existing process, proposes an outcome, and explains its tradeoffs. Then it designs, builds, verifies, and hands over a solution.
I would suggest that students inherit an existing application. Most developers join systems already in use. They need to understand the existing code and data before deciding what to change. Their work should include a plan for deployment, support, and the next person who has to maintain it.
The assessment should include the stakeholder’s experience, the team’s technical decisions, and evidence that the result meets the need. Students should be able to explain what they delegated to AI, how they checked it, what they rejected, and why.
A Foundation, Not a Finished Expert
The business core has the same purpose as the technical core: provide fundamentals that grow with experience. Accounting and finance help a developer understand budgets and tradeoffs. Operations shows how work moves through an organization. Organizational behavior helps explain why stakeholders with different responsibilities can see the same proposal differently.
No graduate leaves as a CFO, attorney, principal architect, and security specialist. A useful degree can prepare them to have a productive conversation with each of those people, recognize when they need help, and keep learning as their responsibilities grow.
I want a graduate who can understand the business, understand the software, and take responsibility for connecting them. AI gives that person more ways to turn an idea into an implementation. Their education should prepare them to decide what to build, guide the work, and determine whether it actually solves the problem.
Receipts
- Earlier essay: Stop Telling Kids to Major in Computer Science explains the business-major and CS-minor recommendation this proposal builds upon.
- AI-assisted development: The University of Washington lists CSE 490A2, which teaches specifications, decomposition, review, debugging, and other development work in an AI-rich context. UW Allen School course catalog.
- Requirements and architecture: UW’s informatics catalog describes INFO 380, Product and Information Systems Management, and INFO 443, Software Architecture for Interactive Systems. They offer examples of connecting organizational needs to system design. UW Informatics catalog.
- Business law: UW Bothell lists B BUS 230, Introduction to Business Law, covering contracts, liability, and other legal foundations. UW Bothell business catalog.
- First-party troubleshooting example: The cross-application database-lock investigation describes my own work. The course sequence is my proposal, not a UW program.