IEEE Software - The Pragmatic Designer: AI Tools Make Design Skills More Important than Ever

Oct 1, 2025 | Mary Shaw, Michael Hilton, George Fairbanks

This column will be published in IEEE Software, The Pragmatic Designer column, Mar-Apr 2026, Vol 43, number 2.

ABSTRACT: As GenAI tools handle more routine programming tasks, the software developer’s responsibilities shift to supervising these tools. Accordingly, the software developer’s success will depend on a skillset that emphasizes reading, critiquing, and modifying code rather than writing programs.

Generative AI (GenAI) and other automated tools are increasingly handling the routine nuts and bolts of creating code. To use them effectively, however, you need to know precisely what you want the tools to generate. It requires close knowledgeable human supervision to specify what you really want (often it is fuzzy), to determine whether generated code does what you specified (often it does not), to judge the quality of the code (often it is poor), to repair AI-generated code if it’s defective (often it is), and to decide whether what you specified to the tool actually describes what the you intended (often it does not).

In other words, the responsibilities of software developers are rapidly becoming more about designing and less about programming. Reading, understanding, evaluating, and repairing someone else’s code is now more important than writing code from scratch. Judging whether you requested the right thing looms larger when the code is not written by you. Attempting to develop complex software without these skills can put a programmer in the position of the Sorcerer’s Apprentice – able to invoke the technology but lacking the skills to control it.

In this column, we examine this shift from coding to design skills through the lens of how to teach “programming” in the new AI age. This reveals the capabilities that current software developers should be cultivating – no longer programming in the traditional sense, but rather software development in cooperation with GenAI tools. We start with the introductory programming course as an example, because it is familiar, it establishes the students’ essential mindset about software development, and it shows the challenges raised by the shift to AI. From there we move on to how GenAI affects software development across the spectrum, not only for university students but also for established software designers.

Our principal point is that the relevant skills for software development are now understanding and modifying code you didn’t write yourself and that this will best be achieved by in-depth study of exemplars of excellent software.

A university curriculum contains both surface topics that are evident to everyone and also deeper objectives. Students in data structures are asked to write linked lists (the surface topic) so that they develop deeper skills: problem analysis, algorithmic thinking, debugging, and evaluation. No one needs another linked list implementation. It is assigned for two reasons: in struggling with it, the student makes progress on the deeper objectives, and the evaluation of the code serves as a proxy for those deeper objectives. Unfortunately, the assignments are often quite imperfect proxies.

Instructors have guided students this way for thousands of years but in just a few years GenAI has disrupted that guidance. GenAI is such a convincing mimic of a student making progress on the deep objectives that instructors are blinded to the actual progress. Reshaping courses for the GenAI world will require rethinking assignments to be more directly connected to the deep objectives.

The implications are profound and are forcing changes throughout the university curriculum. A curriculum is a complex system with many interacting parts. It has, or should have, a description of the capabilities of its graduates. The curriculum achieves this not only through a set of discrete courses, but also through a culture of intellectual engagement that extends beyond the courses and creates a coherent philosophy of learning.

What’s called for is re-examining the course objectives, resetting them if necessary to prioritize enduring principles, then ensuring that student activities serve those objectives. Anyone focusing on the superficial topics (the proxies for the deep objectives) must become more aware of how the curriculum works. Some instructors will need to be reminded of the deep objectives. Students, who can ask GenAI to do their homework in a click, must be acutely aware that the value of their education arises from their struggle. It’s easy for students to conflate industry assignments (where the code is put into production) and course assignments (where the code is discarded), and believe it’s OK to use GenAI on both.

Most disciplines study outstanding exemplars before expecting students to create their own, progressing to more sophisticated works as the students master earlier material. Students study not just the surface text of the exemplars but also their deep structure, their context, and criteria for critiquing them. We think students and experienced software developers should study great exemplars, too, with progressively more complexity as they gain experience. Computer science, alas, has a tradition of expecting students to write code as the primary way to learn software design.

What’s called for is a source of carefully curated exemplars of software systems with interpretive material that supports study of the important qualities of good software. Even more than in years past, developers will need to read, understand, and critique relevant aspects of software in order to modify it – often code written by GenAI.

The introductory computer science course

The principal objective of an introductory computer science course was once – and still should be – for students to learn problem solving using computational tools by applying enduring principles. That is, the course should be about principles such as critical thinking, problem analysis/solving, and careful critique – in other words, about design. Students learn these principles by applying them to specific problems, learning skills with their tools in the process. The initial tasks are small, but this is the time to establish a mindset for quality and good habits for developing software.

Unfortunately, the introductory course has in many places evolved to a programming course in which the objectives are largely the skill of writing small programs to solve given well-specified problems in traditional imperative languages such as C, Java, and Python. That is, the surface topic has become the primary objective. Evaluation is based on the code the students write, rather than the analysis and design steps the students go through in producing that product. The current (2023) ACM/IEEE/AAAI curriculum is still as focused on writing programs as ever. The section on introductory programming, “Fundamental Programming Concepts and Practices”, is all about writing code: the illustrative learning outcomes are mostly (9 of 14) “design, write, test, and debug” one thing or another, and only one is “read a given program and explain…”

Let’s change the introductory course to emphasize reading, understanding, and critiquing code – and applying these skills directly to supervising GenAI tools for code generation.

Today this means teaching students how to supervise genAI tools, which entails designing new activities that lead students through the steps of understanding both the strengths and the weaknesses of these tools and processes for using them well. This involves guiding students in effective use of the tools and revising assignments to ask for interpretation, evaluation, and revision of GenAI results rather than solely coding programs from scratch.

Students must of course continue learning to write code, not just to read it, but the current balance is wrong. Reading itself can be staged, as can writing. This might begin with hand simulation then move to asking whether a given piece of code does X, then revising the code manually or with GenAI so it actually does (or comes closer to doing) X. To develop critical reading skills as students progress, common types of defects and failures could be introduced so that students develop personal checklists of flaws to watch out for.

One special challenge of GenAI is that, unlike previous advances in programming technology and tools, which could be trusted to generate correct results, GenAI cannot be trusted to produce high quality or correct results, which changes the relation between the software developer and tool [1]. We now have tools that can relieve humans of writing large amounts of code, but this comes with uncertainty about the quality and correctness of that code, which together shifts the software developer’s responsibility from coding to design.

Students should be taught to read good exemplars at a scale appropriate to the course. They should learn to think not only about what the examples compute and whether it’s correct, but also about the structure of the software and whether and how the examples achieve quality attributes such as performance, evolvability, and maintainability. This will prepare them to study larger examples later.

Ongoing professional development

Software engineers need to be lifelong learners to keep abreast of emerging technology, and senior engineers need to mentor junior engineers. Success depends on mastering principles, theories, models, and concepts that endure through several changes of technology, in order to learn new tools and examples as they emerge.

In The Mythical Man Month, Brooks observed that moving from a program to a product increases the complexity and effort by a factor of 3; moving from a program to a system does likewise. Doing both, moving from a program to a system product, costs a factor of 9 – about an order of magnitude.

Introductory courses use simple problems, yet these early courses establish the learners’ essential mindset about software quality. Both senior students and junior practitioners must learn to appreciate and handle this growth in complexity. For software that’s part of a system, the internal design decisions matter as much as the surface functionality. As developers mature, they must create robust well-engineered software that satisfies increasingly higher demands for reliability, safety, security, correctness, performance, and other quality attributes. This involves exercising good judgment and tacit knowledge.

Developing that mastery comes not from coding small programs but instead from engaging deeply with good exemplars of large systems. This entails not just reading the code, but also studying interpretive material, observing them in execution, and experimenting with modifications in order to understand them deeply.

Other disciplines develop this judgment by studying shared, well-defined systems with a rich history of analysis and commentary from multiple points of view. Often known as model systems, exemplars, or type problems, they provide a way to compare methods and results, work out new techniques on standard examples, and set a minimum standard of capability for new participants. Biology, for example, has the fruit fly and the lab rat. Software engineering is short of these but there are efforts to develop such exemplars in specific areas [2].

The skill of supervising AI tools thus depends critically on knowing the technology of the implementation in order to supervise the tools – critically evaluating the AI outputs and, as is often necessary, improving them either manually or with tool-based refinement. Developing that mastery requires studying good exemplars, a task that is more difficult the more complex the systems are.

Let’s develop a curated collection of great examples of well-engineered software, with supplemental material to interpret why they’re great.

Empirical research shows that GenAI tools can be helpful to developers who have a broad and solid knowledge base, and who understand the strengths and weaknesses of the tools. However, in the hands of inexperienced developers. GenAI tools can be counterproductive, presumably because they lack understanding of the tools and how to use them [3]. The next generation of developers must master skills and judgement that go beyond classroom examples, such as the skills to design safety-critical, high-assurance, and secure code.

The transition to genAI must support developing software that is fit for its intended purpose. Doing this requires determining the level of quality required for a particular task. Some software is sufficiently critical to justify the effort of extensive validation. For other software, “good enough” is good enough. The question of whether the software is “good enough” depends on the consequences of failure, the odds that someone (or some thing) will actually intervene before failure, and problem-specific context. If the quality standards are not set appropriately, fitness for purpose may be lost [4].

Today’s students must grow into tomorrow’s developers who have both real appreciation of the technology and a mindset that seeks correctness over mere box-checking. They must develop their own judgement for what “good enough” means based on the consequences of failure.

The challenge

This column challenges the status quo in computing education. It argues that we should revisit educational objectives to be sure they lead to the durable, deep skills (algorithmic thinking, clear formulation of problems, solving those problems with computational tools, debugging, and evaluating candidate solutions, and code repair) in the context of current technology. It argues that we should revise – likely drastically – educational content to emphasize the analysis that leads to the solution to an assignment, not merely the finished product.

Technology is advancing and educators should embrace it. Let’s teach learners critical thinking with current technologies and let them use the tools that help with lower-level tasks; the need to check and revise GenAI results provides the setting for teaching them the skills that used to be front and center.

We have identified the challenge and some avenues to explore. We don’t pretend to solve everything and many questions remain. For example:

• How do we find excellent exemplars? How do we decide that they are excellent? Can we create them, or must we find them in the wild? Can we identify some that serve us as model problems? Several existing efforts are identified in [2]
• How do we encourage learners to shift from hacking out code to understanding that there are problems for which mere hacking is unsuitable?
• How can they develop the judgement about what quality standard to use on a system – when quick and dirty is ok, and when only the best will do?
• How do we strike the right balance between learners studying good examples and creating their own?
• How do we reach the vast numbers of programmers who don’t get formal education in programming – the ones who pick it up informally, on their own?

GenAI has disrupted the standard way that instructors evaluate students’ progress. Though many instructors are grumbling loudly, we should treat this as a gift because it guides us to reconsider our standard ways of teaching and consider alternatives.

Acknowledgements

Thanks to Dan Gillmor, Irving Wladawsky-Berger, André van der Hoek, Owen Cheng, Marian Petre, Ipek Ozkaya, David Kosbie, Dave Eckhardt, John Mackey, Dave Farber, Rich Kulawiec, Ed Frakenberry, Nick Kelly, Rohan Padhye, David Garlan, Titus Winters, Andrea Scaduto, Sushil Birla for constructive comments and suggestions.

References

1. Eunsuk Kang and Mary Shaw. 2024. “Tl;dr: Chill, y’all: AI Will Not Devour SE.” Proc. Onward! ‘24, pp 303–315. https://doi.org/10.1145/3689492.3689816.

2. Mary Shaw and Eunsuk Kang. “Model Problems in Software Engineering.” Accessed: Oct. 1, 2025. [Online]. Available: https://modelproblems.org.

3. Matthew Kam, et al.. 2025. “What do professional software developers need to know to succeed in an age of Artificial Intelligence?” Proc 33rd ACM int’l Conf on Foundations of Software Engineering (FSE Companion ‘25), pp 947–958. https://doi.org/10.1145/3696630.3727251.

4. Mary Shaw. 2022. “Myths and mythconceptions: what does it mean to be a programming language, anyhow?” Proc. ACM Program. Lang. 4, HOPL, Article 234 (June 2020), 44 pages. Refer to pp. 234:21-22. https://doi.org/10.114 5/3480947.

Author bios

• Mary Shaw is the A. J. Perlis University Professor of Computer Science in the School of Computer Science at Carnegie Mellon University, specializing in software engineering.
• Dr. Michael Hilton is a Teaching Professor in the School of Computer Science at Carnegie Mellon University, specializing in software engineering education.