Contents

As AI Takes Over Coding, What Hard Problems Are Left in Software Engineering?

https://leafw-blog-pic.oss-cn-hangzhou.aliyuncs.com/software-engineering-handbook-cover.png

I recently read a new book in software engineering, James C. Davis’s The Software Engineering Handbook: A Judgment and Decision-Making Approach.

The first edition was published in September 2026. This article is based on the version updated on November 17.

The topics it covers are fairly traditional: requirements analysis, the development process, teamwork, software architecture, design, testing and validation, and the management of engineering knowledge. But the author chose a starting point that feels very timely: as AI can take on more and more of the coding work, how should software engineers develop and apply engineering judgment?

Over the past few years, AI programming tools have advanced quickly. From early code completion to today’s Coding Agents that can read a repository, edit multiple files, and run tests, the way software is built has already changed in noticeable ways.

Implementation work that once took engineers a great deal of time can now, to some extent, be handed to AI.

That shift also raises a problem.

In the past, junior engineers typically built experience by writing code, debugging programs, fixing defects, and maintaining systems. As AI takes over some of this routine work, that path of growth may be affected.

In the preface, the author notes that newcomers may be asked to guide and evaluate machine-generated work before they have formed enough engineering judgment through practice.

That is also the starting point of the book.

The author wants to turn engineering judgment, which in the past was accumulated mainly through experience, into knowledge that can be learned, discussed, and practiced.

1. Software Engineering Is a Discipline of Controlled Change

In Chapter 1, the author offers a definition:

Software engineering is the engineering discipline of controlled change in software systems.

Why emphasize change?

The author first looks at several properties of software as an engineering medium:

  • Changeable. Software behavior can continue to be modified after it has been built.
  • Copyable. Once software is finished, the cost of copying it is usually very low.
  • Transferable. Software capabilities can be moved to different devices and runtime environments.
  • Updateable. After software is deployed, it can still be repaired and extended.

These properties set software far apart from traditional engineering materials.

Once a bridge is built, changing its structure requires a huge physical cost. Software can change a system’s behavior with a single update, and can even deploy the modified program to millions of devices at the same time.

Software’s changeability gives engineers enormous influence, and it also brings corresponding risk.

A correct change can quickly benefit a large number of users; an incorrect change can just as easily affect the entire system.

A new feature may break existing behavior, a performance optimization may introduce concurrency problems, and a dependency upgrade may affect security boundaries. As a system grows, the reach of a local change can also become harder and harder to predict.

So software engineering has to keep answering a few questions:

What should change? What is allowed to change? What must stay the same? And how do we demonstrate that a change is acceptable?

The book uses a payment system as an example.

Suppose the system needs to add a new payment method. Implementing the corresponding business logic is only part of the work. Engineers also need to make sure existing security properties are not affected, that clients and historical data remain compatible, and that they have enough evidence of validation.

That is what the author calls Controlled Change.

The “control” here does not mean preventing change, nor does it require engineers to personally decide every implementation detail. Engineers need to understand which properties must be protected, and to ensure that the system’s evolution stays within acceptable bounds.

2. AI Is Moving the Bottleneck in Software Engineering

In Chapter 1, the author also discusses how technical progress changes the cost structure of engineering work.

High-level programming languages lowered the cost of writing machine instructions.

Operating systems and software libraries provided basic capabilities that could be reused directly.

The open-source ecosystem reduced a great deal of duplicated implementation work.

Cloud computing made computing resources available on demand.

Each of these advances lowered the cost of certain kinds of work, and at the same time let engineers spend more of their effort on other problems.

Generative AI and Coding Agents are continuing that process.

In the past, software development required a large amount of time for concrete implementation. Writing interfaces, handling exceptions, changing code, and adding tests were usually things engineers had to do themselves.

Today, Coding Agents can already take part in many of those steps.

But faster code generation does not automatically solve the other problems in software engineering.

Suppose we need to build a new business system.

AI can quickly generate code from a requirements description, but someone still has to judge:

  • Whether the requirements are clear enough, and whether important business scenarios have been missed.
  • What architecture the system should use, and how responsibilities should be divided among components.
  • Which business rules, security constraints, and performance requirements must be satisfied.
  • Which technical decisions will affect future maintenance costs.
  • Whether the test results are enough to show that the system can be delivered.

As the cost of implementation falls, the relative importance of these decisions across the whole engineering activity will only grow.

The author writes:

The bottleneck moves.

That also explains why AI’s ability to generate large amounts of code does not mean software engineering itself becomes simple.

Code generation is only one part of software engineering. A system still has to meet requirements, adapt to a changing environment, and stay reliable over long-term maintenance.

For teams using Coding Agents, engineers may do less of the coding themselves, but they will need to spend more effort defining tasks, evaluating approaches, verifying results, and controlling risk.

3. Engineering Judgment Shows Up First in How We Make Decisions

Chapter 2 discusses the software development process.

The author does not simply treat waterfall and agile as two competing methods. Starting from the engineering problem itself, he proposes three dimensions that affect the choice of development process.

1. Certainty: How much can we know in advance?

Some projects have very clear requirements.

For example, implementing a data-exchange interface according to an already settled protocol, where the inputs, outputs, and constraints are relatively stable.

In that situation, completing thorough planning and design up front is usually valuable.

But if you are building an entirely new product, how users will use it and which features actually matter may only become clear after the product is in use.

In that case, getting feedback through incremental development can help the team reduce uncertainty.

The author emphasizes that the development process should fit the way information is obtained.

If important information can be obtained in advance, planning should be used fully.

If important information can only be obtained by building and using the system, the process should be set up to produce feedback as early as possible.

2. Changeability: How costly is it to reverse a decision?

The book gives a very intuitive example.

Suppose it would take three days to analyze the best value for some configuration parameter, but if you choose poorly, it would take only twenty minutes the next day to change it.

Then spending three days in advance to find the best answer may not be worthwhile.

Now consider a different scenario.

If you are designing a public API that hundreds of systems depend on, later changes after release may require coordinating a large number of upstream and downstream systems.

That kind of decision is worth more analysis up front.

The author’s principle can be summarized as:

The harder a decision is to reverse, the more it is worth analyzing in advance; the easier a decision is to change, the more it makes sense to get feedback through practice.

The same applies to AI programming.

Having an Agent rewrite an ordinary utility class may take only a few minutes, but the cost of changing a database structure, a public interface, a security protocol, or an architectural boundary does not fall in step just because AI can generate code quickly.

So in AI-assisted development, it remains very important to distinguish decisions that can be tried quickly from decisions that need to be handled with care.

3. Decomposability: Can we get value from a partial implementation?

The third dimension is decomposability.

Some systems have to be completed as a whole before they can do anything useful, but a great deal of software can be built in stages.

For example, an e-commerce system can first implement product search and basic payment, then gradually add recommendations, coupons, and other features.

Even if a partial implementation cannot yet be delivered to users, as long as it can validate a technical assumption or provide valuable information, incremental development may still be a reasonable choice.

The author also draws a particular distinction between the development process and the intensity of validation.

The more serious the consequences of a system failure, the stronger the evidence usually needed to support delivery. But that does not directly determine which development process must be used.

High-risk systems can also be developed iteratively; each important change simply has to meet the corresponding validation requirements.

Taken together, these dimensions show that software engineering rarely has a fixed answer that fits every situation.

Engineers need to choose among approaches according to the characteristics of the problem itself.

4. Engineering Knowledge Should Remain Useful Over Time

Chapter 4, Engineering Knowledge, discusses a problem that is easy to overlook:

How should what engineers learn persist?

In long-lived software projects, we often run into situations like these.

A system uses a design that looks unreasonable, but no one still knows why it was done that way.

An interface has a special rate-limiting rule, and the engineers who later take it over only know that it cannot be changed, without understanding the specific reason.

A database field looks as if it could be deleted, but in fact it has historical business dependencies.

These problems all involve the loss of engineering knowledge.

The author argues that engineering knowledge includes information about the system itself, and also the decisions made around the system.

For example:

  • Why a particular technical approach was chosen.
  • Which alternatives were considered at the time.
  • Which assumptions supported the decision.
  • What measurements can support it.
  • What failures have occurred.
  • Which issues remain uncertain.

Suppose a team decides to use PostgreSQL.

If the documentation only records “the database is PostgreSQL,” future engineers will have a hard time judging whether that choice is still reasonable.

But if it also records the business context at the time, the data scale, the query needs, the performance-test results, and the other candidates, later people can re-evaluate the choice under new conditions.

The author also cautions that managing engineering knowledge does not mean recording everything.

Documentation has a maintenance cost, records can go stale, and too much information increases the cost of understanding.

Engineers need to judge which knowledge is worth keeping, in what form it should be kept, and when it needs to be re-validated.

What Does This Have to Do with Agent Development?

From the standpoint of AI Agent engineering practice, this chapter is especially suggestive.

Many Coding Agents already support obtaining engineering knowledge through project rule files, Skills, tool calls, and other context mechanisms.

We can provide Agents with project architecture conventions, interface constraints, business restrictions, testing requirements, and so on.

But merely letting an Agent read the documentation is not enough to solve every problem.

For example, a system once caused duplicate message consumption because of a mistaken retry strategy.

If that incident lives only in an accident report that no one reads, later development may still run into similar problems.

If the team goes further and turns the experience into explicit idempotency requirements, automated tests, and code checks, the knowledge produced by the incident can continue to shape later development.

This line of thinking is related to Model-Based Agentic Engineering (MAGE), which the author mentions in the preface.

MAGE emphasizes making important engineering knowledge explicit, making key constraints enforceable, and turning recurring engineering judgments into mechanisms that can be reused over time.

In practice, these ideas can be applied to an Agent’s rule files, Skills, and automated tests. Which mechanisms to use still has to be decided according to the project.

5. Requirements, Specifications, Architecture, and Design Address Different Layers of the Problem

Chapters 5 through 8 discuss Requirements, Specification, Architecture, and Design.

These chapters can be understood together.

Requirements: What should we commit to building?

Requirements engineering has to judge what can create value, and, under limited resources, what the team can responsibly commit to.

Specification: What do those commitments actually mean?

A specification turns requirements into explicit constraints, so that engineers can judge which implementations are acceptable and which ones violate the requirements.

Architecture: How should the system be organized to satisfy these constraints?

Architecture determines the system’s main boundaries, the allocation of responsibilities, and the relationships among components, and it controls how local changes affect other parts.

Design: Given the architecture, how should it be implemented in detail?

Design further addresses the mechanisms of local implementation, and compares options through analysis and evidence.

These concepts are familiar in traditional software engineering, but they become even more important in an AI programming setting.

Suppose we ask an Agent to build a system that generates marketing scripts for a bank.

If we only tell it to “generate marketing scripts from customer information,” the Agent may quickly produce a version that runs.

But that requirement leaves many important questions unstated.

For example:

Which customer information is allowed to be used?

Is it allowed to promise investment returns?

What structure should the generated result follow?

What content needs to go through compliance checks?

What should happen when the model cannot determine an answer?

These questions need to be answered at the requirements and specification stages.

Only then come the architectural choices.

How should capabilities such as script generation, reading customer information, compliance checks, and logging be organized? Which operations can the Agent carry out on its own? Which must be handed to deterministic business services?

Only then do we get to concrete implementation, such as the choice of framework, the organization of the code, model calls, and exception handling.

AI can take part in work at each of these layers, but engineers need to make clear which constraints must not be violated, and which implementation details can be left with some freedom.

That is also an important question the author discusses in the chapter on specifications.

What should we constrain, and what choice should we leave open?

Too few constraints can allow the system to produce unacceptable behavior.

Too many constraints can raise maintenance costs and rule out reasonable implementations.

Engineering judgment has to find a balance that fits the problem at hand.

6. How Do We Show That AI-Generated Code Is Reliable?

Chapter 9, Validation, is one of the chapters in the book most worth paying attention to.

As Coding Agents become more capable, we often run into a scene like this:

The Agent has finished the code changes, run the tests, and then reported that the task is done.

But what do those results actually prove?

The author argues that validation should start from a concrete engineering claim.

For example, a system claims to support 1,000 concurrent requests with P99 latency below 500ms.

Then we need to run performance tests under appropriate environment and load conditions before we can have evidence that supports this claim.

All unit tests passing does not prove that the performance requirements have been met.

Likewise, 90% code coverage does not by itself prove that the system has no important defects.

Different metrics can only reflect certain properties of a system.

In the introduction, the author offers a reasoning framework that runs through the whole book:

Model → Property → Observation → Evidence → Judgment

That is:

model → property → observation → evidence → judgment.

Engineers first build an understanding of the system, make clear which properties the system should have, then obtain evidence through observation and measurement, and finally make a judgment based on that evidence.

There is another important point here: metrics themselves are also models.

For example, code coverage can help us understand which code the tests executed, but it does not directly represent software quality.

Interface response time can reflect performance, but it cannot by itself say whether the system is reliable.

So engineers need to understand what a metric can tell us, what it leaves out, and whether the conditions of measurement match actual use.

Validation Needs to Match the Risk

The author also emphasizes that the consequences of failure affect how strong the evidence for validation needs to be.

An internal utility and a banking system that handles money clearly have different validation requirements.

For AI-generated code, different forms of validation can be chosen according to the specific risk.

Functional correctness can be checked with automated tests.

Interface compatibility can be checked with contract tests.

Performance requirements need to be checked with benchmarks.

Security may need static analysis, permission tests, and other targeted checks.

Complex business rules need explicit business acceptance criteria.

These methods are not new in themselves, but as code is generated faster and faster, validation may become an important bottleneck in the delivery process.

AI can help write tests, run checks, and analyze results, but whether the tests are sufficient and whether the evidence is trustworthy still has to be judged against the system’s actual requirements.

One situation especially needs care: the Agent generates the code, also generates the tests, and then all the tests pass.

If the tests themselves omit important constraints, a passing test suite still cannot prove that the implementation meets the real business requirements.

7. Engineering Experience Comes from Reflecting on the Results of Decisions

The title of the book’s final chapter is Failure-Aware Engineering, which can be understood as engineering practice that stays aware of failure.

The author quotes a line from the engineering historian Henry Petroski:

Failure is central to engineering.

Software engineering always faces incomplete information, imperfect models, and limited validation evidence.

Even after thorough design and testing, a system can still fail.

What the author cares about is how engineers should use that information when actual results diverge from expectations.

For example, a service fails because of a concurrency problem.

We can fix the code and then close the incident ticket.

But if we want to build engineering capability from the failure, we also need to look further:

Why wasn’t the problem identified in the design phase?

Why didn’t testing catch it?

Were there mistaken assumptions in the system model?

Do other modules have similar risks?

What tests, constraints, or protective mechanisms should be added?

In the book, the author uses a process to explain how experience is formed:

Decision → Consequence → Reflection → Repertoire

Decision, consequence, and reflection, eventually forming experience that can be used in the future.

Repertoire here can be understood as the situational recognition and response capability that an engineer accumulates.

Experienced engineers can often notice that a design may be risky before the problem actually occurs.

That ability comes from past decisions, actual results, and reflection on the difference between the two.

The author emphasizes in particular that experience does not form automatically just because years on the job increase.

If engineers keep repeating the same work without connecting results back to their earlier judgments, the accumulation of experience may be very limited.

And experience should not remain only with individuals.

An important lesson from a failure can be turned into automated tests, architectural constraints, development conventions, or knowledge shared by the team.

That way, even if the original engineer leaves, the experience can continue to be useful.

The same mechanism is also relevant for AI Agents.

When an Agent repeatedly makes a certain kind of error, we can add the failure cases to an evaluation set, turn important business restrictions into checkable constraints, and use automation to lower the chance that similar problems happen again.

Of course, not every failure needs a new rule.

New constraints also have a maintenance cost, and engineers still need to judge how serious the problem is, how likely it is to recur, and whether the improvement is worth it.

8. What Capabilities Do Software Engineers Need in the Age of AI?

After finishing the book, you can see that the author stays with one question throughout:

As the cost of implementing software keeps falling, how should engineers keep control of the system?

In the past, a strong software engineer usually needed solid programming skill, the ability to understand complex code, familiarity with technical frameworks, and the ability to independently solve problems that came up in development.

Those capabilities still matter.

But as AI programming tools develop, advantages built only on the speed of producing code may gradually shrink.

At the same time, the importance of other capabilities will grow.

For example, understanding business goals, identifying key constraints, comparing architectural options, judging validation evidence, and extracting lessons from production failures.

That does not mean future software engineers can get by without understanding code at all.

If you cannot understand how a system is implemented, it is hard to evaluate AI’s work effectively, and hard to take engineering responsibility when complex problems appear.

In the definition of Engineering in Chapter 1, the author emphasizes that engineers do not need to personally perform every action required to implement a system, but they must retain enough control to guide the work, understand the consequences, evaluate the evidence, and intervene when necessary.

This is especially important for AI-assisted development.

As more and more implementation work is done by Agents, engineers still have to be responsible for key decisions and for the system’s results.

At the same time, AI also raises new questions about how engineers are trained.

In the past, junior engineers could gradually accumulate experience through a large amount of relatively simple coding, debugging, and maintenance work.

If much of that work is handed to AI, newcomers may lack the practice they need to form engineering judgment.

In the preface, the author uses a vivid metaphor.

In the past, we could let students graduate as caterpillars, and then industry would, through practice, turn them into butterflies.

Now, we need students to already have a certain amount of engineering judgment when they graduate, and to become “small butterflies” who can keep growing.

That metaphor also explains why the author wrote this book.

He wants to bring into software engineering education, earlier than before, some of the methods of judgment that engineers previously could obtain only through long practice.

Closing

The Software Engineering Handbook does not offer a concrete AI programming workflow, and it does not discuss which Coding Agent or development framework one should choose.

What it tries to answer is a more basic question: as implementation technology keeps changing, which capabilities in software engineering remain important?

The author concentrates the answer on engineering judgment.

From requirements analysis to architectural design, from implementation choices to testing and validation, and on to incident reviews, software engineering always requires decisions under limited information and resource constraints.

AI can help engineers do more and more of the implementation work, and it can also help analyze options, write tests, and find problems.

But whether those capabilities can truly be turned into reliable software systems still depends on whether engineers can make goals explicit, establish constraints, evaluate evidence, and continually revise their judgment in light of actual results.

The main thing this book left me with is that, as AI programming tools continue to develop, software engineers need to pay more attention to the problems that cannot be solved directly by generating code.

These include whether a requirement is worth implementing, whether an architectural decision is sound, whether a change to the system is under control, whether the validation evidence is sufficient, and whether engineering experience can keep accumulating within the team.

These problems have long existed in software engineering. The development of AI gives us a chance to spend more time on them, and it also makes the cost of lacking engineering judgment more obvious.


References

  1. James C. Davis, The Software Engineering Handbook: A Judgment and Decision-Making Approach, First Edition, 2026. This article is based on the version updated on November 17, 2026.
  2. James C. Davis, Model-Based Agentic Engineering, 2026. https://davisjam.github.io/model-based-agentic-software-engineering/book/mage-book/index.html
  3. Frederick P. Brooks, No Silver Bullet: Essence and Accidents of Software Engineering, IEEE Computer, 1987.
  4. Donald A. Schön, The Reflective Practitioner: How Professionals Think in Action, Basic Books, 1983.