There is a child in a classroom today who may grow up and find it strange that humans once learned almost entirely without artificial intelligence.
That child may wonder why students memorised facts from slides, drilled syntax from textbooks, waited for one teacher to explain the same idea to many different minds, and submitted assignments days or weeks later without intelligent feedback. To that child, learning without AI may feel as old as learning without the internet, calculators, or electricity.
“AI will not replace the teacher. But it will change what it means to teach, what it means to learn, and what it means to be capable.”
AI is changing the basic structure of learning. For the first time, a learner can have a tutor, coding partner, reviewer, simulator, translator, and critic available at the moment of need. The question for universities is no longer whether students will use AI. Many already do. The real question is whether higher education will redesign learning around this reality, or continue treating AI as a side tool.
Software engineering sits close to the centre of this shift. It is both the field building many of these tools and the field being transformed by them.
For decades, introductory software engineering courses have followed a familiar pattern. We teach what software engineering is, what the software development life cycle means, how requirements are collected, how design leads to implementation, how testing fits into the process, and how maintenance comes after delivery.
But the context has changed.
Software is no longer built only by humans writing every line of code manually. Increasingly, it is co-created with AI systems that can generate code, explain code, refactor code, write tests, create user interfaces, summarise requirements, and help developers understand unfamiliar systems.
There is early empirical evidence that AI coding assistants can affect developer productivity in specific settings. In one controlled experiment, developers using GitHub Copilot completed a JavaScript programming task 55.8% faster than those without it. This was one task in one experimental setting, so it should not be treated as a universal productivity rule [1].
Another study, based on three field experiments with 4,867 developers, reported a 26.08% increase in completed tasks among developers using an AI coding assistant. Again, this does not mean that every developer or every software team will become 26% more productive. Software engineering is too complex for such a simple conclusion [2].
The graduate of 2030 will not enter the same software industry that shaped many of today’s courses.
The old debate is repeating itself
Every generation of programmers has faced a moment when a new abstraction looked like a threat. Later, that abstraction often became normal practice.
Recently, I was discussing this shift with a colleague who has decades of experience in programming languages. He described how he started from machine-level and assembly-level code, then moved toward higher-level languages such as C and C++. He remembered a time when some programmers resisted compilers. For them, real programming meant controlling the machine directly. A compiler looked like something that could make programmers lazy and hide important details.
History proved something more nuanced.
Compilers did not remove the need for programming knowledge. They changed what counted as programming knowledge. Developers no longer had to manage every machine instruction manually, but they still needed to understand logic, memory, performance, correctness, structure, and trade-offs. The intellectual focus moved upward.
“AI is the next upward movement.”
The question is not, “Should students still learn programming?” Of course they should. The better question is, “What kind of programming should students learn when AI can generate syntactically correct code faster than most beginners?”
If a student can ask an AI assistant to generate a Python API, a React interface, a database schema, and unit tests in minutes, then a course built mainly around syntax memorisation becomes incomplete. Syntax still matters, but it can no longer be the centre of programming education.
“We should not teach students to compete with AI at typing code. We should teach them to understand problems, guide tools, evaluate outputs, and take responsibility for software systems.”
From traditional software engineering to AI-native software engineering
AI-native software engineering is not software engineering with a chatbot added. It is software engineering redesigned for a world where intelligent assistance is part of the development environment.
Traditional software engineering often presents development as a sequence of human activities: requirements, design, implementation, testing, deployment, and maintenance. These activities still exist, but they are becoming more interactive and tool-mediated.
Requirements may be summarised with AI, converted into user stories, checked for ambiguity, and tested through quick prototypes. But students must still learn how to validate requirements with real users, real constraints, and real organisational goals.
Design can be supported by AI-generated diagrams, architectural alternatives, and trade-off comparisons. But students must judge whether a design is secure, scalable, maintainable, understandable, and suitable for the business context.
AI can generate implementation and tests, but students must know whether the solution is correct, efficient, readable, legally safe, and aligned with the system’s architecture. They must also understand why passing tests does not always mean the system is correct.
Maintenance is no longer only bug fixing. It includes migration, re-engineering, technical debt management, AI feature integration, data pipeline improvement, and monitoring.
This is why the phrase AI-native software engineering matters. It means redesigning software engineering education around the reality that AI is becoming part of the development environment.
What must change in the way we teach
The first change is pedagogical. Students should not learn software engineering as a collection of isolated topics. They should learn it as a way of thinking about systems.
Programming is a good example. Students should still learn variables, control flow, functions, data structures, modularity, and object-oriented programming. But they should not learn them mainly as syntax exercises. They should learn them as tools for understanding behaviour.
A student should be able to read code carefully, explain what it does, predict its output, identify hidden assumptions, test edge cases, and improve it. They should compare human-written and AI-generated solutions and ask why one solution is better than another.
In the AI era, the question is no longer only whether a student can produce code. The question is whether the student can recognise good code.
Instead of asking only, “Can you write this program from scratch?”, we should also ask:
“Can you evaluate three AI-generated solutions, identify their weaknesses, test them properly, and improve the best one?”
This does not weaken learning. It can deepen learning, because the student is forced to reason about correctness, efficiency, readability, and design.
The same principle applies across the curriculum.
Data structures and algorithms remain important because they build mental models. They teach students how to think about scale, cost, constraints, and problem structure. In the AI era, these subjects should become less about memorising implementations and more about developing computational judgement.
Database education must also expand. Students still need SQL, relational design, indexing, and transactions. But modern systems increasingly work with structured, semi-structured, and unstructured data: customer records, support tickets, PDFs, logs, source code, images, and internal knowledge bases.
“In intelligent software, data is not just something we store. It is something the system retrieves from, reasons with, and sometimes misunderstands.”
This means students also need to understand data quality, privacy, governance, search, embeddings, vector databases, and retrieval-augmented generation.
Web development also needs to change. AI-assisted tools can now help create interfaces, backend logic, dashboards, and early prototypes from natural language instructions. This gives students a powerful opportunity, but also creates a danger. A generated web application may look complete while hiding insecure authentication, poor data validation, weak error handling, accessibility problems, or fragile backend logic.
“A working screen is not the same as a working system.”
Students should learn how web systems actually work: APIs, authentication, authorisation, security, accessibility, performance, deployment, monitoring, and maintenance. AI can help generate a prototype, but the student must learn how to inspect it like an engineer.
Software architecture becomes even more important. When code becomes easier to produce, design decisions become more important. AI can generate many versions of a system quickly, but it cannot automatically know which version fits the organisation, users, regulations, legacy systems, security constraints, and long-term maintenance plan.
“When code becomes easier to produce, design decisions become harder to avoid.”
Architecture is where software engineering becomes judgement. Students should learn how to ask AI for architectural alternatives, compare trade-offs, identify risks, document decisions, and justify why one design is better than another. They should also learn restraint. Not every system needs generative AI. Not every system needs microservices. Sometimes a simple architecture is the best architecture.
Universities often love new systems. Students build new apps, prototypes, projects, and demos. These activities are useful, but they do not fully represent industrial software engineering.
The future of software engineering will not be built only on blank screens. It will be built inside existing systems, old codebases, messy data, and organisations that cannot simply start again.
Most real software work is not greenfield development. It is understanding, maintaining, migrating, integrating, and improving systems that already exist.
In the AI era, companies will ask practical questions. How can we add AI features to our current product? How can we improve existing data? How can we connect a legacy system to a modern AI service? How can we migrate old code safely? How can we introduce automation without breaking privacy, security, compliance, or user trust?
This means universities need to teach re-engineering, migration, software modernisation, and AI adoption in existing products more seriously.
“Innovation is not always a new application. Often, it is an old system made safer, smarter, and more useful.”
What universities should teach now
If software engineering education is to remain relevant, universities need a new core built around AI-native development. This does not mean removing foundations. It means teaching foundations through a new lens.
Students need programming, algorithms, databases, web development, architecture, testing, security, ethics, teamwork, and maintenance. But each area must now include a new layer of competence: how to work with AI without becoming dependent on it.
They should learn AI-assisted coding, code review, debugging, refactoring, and verification. They should understand data quality, retrieval, governance, and privacy. They should know that fast prototyping is not the same as safe deployment. They should learn why testing and quality assurance become more important when code is easier to generate.
They also need to learn how to work with AI as a collaborator: prompting, task decomposition, agent supervision, output evaluation, documentation, and responsible use. The future software engineer must know how to question AI, guide AI, and take responsibility for the final system.
This may require both redesigning existing courses and introducing new ones. Universities may need courses such as AI-Native Software Engineering, Human-AI Programming, Software Testing and Verification for AI-Generated Code, Data Systems for Intelligent Software, AI-Enabled Software Architecture, and Legacy System Modernisation with AI.
These should not be short tool-training courses. They should teach durable abilities: how to reason with AI, verify AI outputs, design trustworthy systems, and integrate AI safely into real software products.
This is not only a classroom concern. It is also a labour-market concern. The World Economic Forum’s Future of Jobs Report 2025 identifies AI and big data, networks and cybersecurity, and technological literacy among the fastest-growing skills expected to rise in importance between 2025 and 2030. The same report states that employers expect 39% of workers’ core skills to change by 2030. This should not be read as panic. It should be read as a signal that universities must take skill transformation seriously [3].
UNESCO’s guidance on generative AI in education and research also supports a careful, human-centred approach. It highlights data privacy concerns, institutional readiness to validate tools, long-term policy planning, human capacity development, human agency, inclusion, and equity. In simple terms, the educational response to AI should not be blind adoption. It should be thoughtful redesign [4].
The teacher’s role is not smaller. It is higher.
The strongest argument against AI in education is fear: fear that students will stop thinking, stop reading, stop coding, stop struggling, and simply outsource learning to machines.
This fear is not foolish. It is a real risk. But the answer is not to pretend AI does not exist. The answer is to redesign learning so that AI use requires thinking rather than replacing it.
Teachers will become more important, not less. The teacher will no longer be mainly the person who transfers information. The teacher becomes the designer of learning environments, the guardian of intellectual standards, the coach of judgement, and the person who helps students connect technical skill with human purpose.
“AI can give answers quickly. Teachers must help students ask better questions and judge the answers they receive.”
In the old model, the teacher explained and the student repeated. In the AI-native model, the student explores, builds, questions, tests, reflects, and improves, while the teacher ensures that learning remains deep, ethical, and intellectually honest.
We may be teaching the last generation of students who remember learning before AI became ordinary.
This is comparable to the arrival of calculators in mathematics, search engines in research, and compilers in programming. Each technology changed not only what students could do, but what education needed to mean.
Software engineering education now faces that moment.
If we continue teaching as before, we may produce graduates who can describe the software development life cycle but cannot work effectively in AI-mediated teams. They may know syntax but not verification. They may build prototypes but not trustworthy systems. They may use AI but not understand its risks.
But if we redesign thoughtfully, we can produce graduates who understand fundamentals, use AI responsibly, think architecturally, work with data intelligently, modernise existing systems, and build software that is not only fast to generate but safe to trust.
AI will not replace the teacher. But it may force education to become what it always promised to be: personal, active, reflective, creative, and connected to the real world.
“The future software engineer will not be the person who writes every line alone. The future software engineer will be the person who knows what should be built, why it matters, how to guide intelligent tools, how to verify the result, and how to take responsibility for the system that enters the world.”
References
[1] Peng, S., Kalliamvakou, E., Cihon, P., & Demirer, M. (2023). The Impact of AI on Developer Productivity: Evidence from GitHub Copilot. arXiv. https://arxiv.org/abs/2302.06590
[2] Cui, Z., Demirer, M., Jaffe, S., Musolff, L., Peng, S., & Salz, T. (2025). The Effects of Generative AI on High-Skilled Work: Evidence from Three Field Experiments with Software Developers. Microsoft Research. https://www.microsoft.com/en-us/research/publication/the-effects-of-generative-ai-on-high-skilled-work-evidence-from-three-field-experiments-with-software-developers/
[3] World Economic Forum. (2025). The Future of Jobs Report 2025: Skills Outlook. https://www.weforum.org/publications/the-future-of-jobs-report-2025/in-full/3-skills-outlook/
[4] UNESCO. (2023). Guidance for Generative AI in Education and Research. https://unesdoc.unesco.org/ark:/48223/pf0000386693.locale=en
About the author
