AI Coding 中，人在做什么？

When AI can read code, change features, add tests, and even iteratively attempt fixes based on error messages, a question becomes concrete:

If code is mainly written by AI, what remains for developers to do?

Looking at a real development process, you'll find that between entering a requirement and generating code, there are many places where human judgment is required. The faster code is generated, the more these judgments affect the final result.

一、把一句需求变成一个明确的问题

"Add a cancel feature to orders."

This sentence is enough to start a conversation, but not enough to develop directly.

Which orders can be cancelled? Can an order be cancelled after payment? Does cancellation require a refund? When is inventory released? How should duplicate clicks be handled? If calling an external system fails, which state should the order remain in?

AI can help list these questions, and can also infer answers from existing code. But inferences need confirmation, especially when business rules and trade-offs are involved.

What a human needs to do here is find the real problem that needs solving and make clear what result is acceptable.

Sometimes, after discussion, it turns out users only need to "submit a cancellation request" and actual cancellation still requires review. If you let AI implement immediate cancellation from the start, the more complete the code, the larger the rework scope might be.

In AI Coding, the first human job is to make the requirement worth implementing explicit.

二、给 AI 足够可信的上下文

When a developer receives a task, they rarely rely only on the requirement text. They also consider:

• What implementations already exist in the project.
• Which modules are responsible for which business logic.
• Who calls the current interface.
• What conventions the team follows.
• Which historical pitfalls must be avoided.

AI needs this information too.

For example, if the project already has a unified pagination entry, and this context is not provided, AI might write a separate pagination logic. The code might run in isolation, but adding it to the project increases maintenance cost.

The human's work includes finding relevant information, helping AI locate trustworthy sources, and resolving conflicts between materials. When documentation says one rule and code implements another, someone needs to confirm which one represents the current business.

This also pushes developers to write down the experience that used to live in their heads. Those "everyone knows" conventions only become stable inputs for colleagues and AI when they are written down as accessible, updatable materials.

三、决定改到哪里，什么时候停

AI can often keep going: after fixing one problem, it might tidy up adjacent code; after adding an interface, it might extract a common component.

These changes might each have their own justification, but every additional change increases the scope of understanding, review, and verification.

Suppose the task is only to fix a decimal rounding issue in an amount display, but AI also adjusts the entire amount calculation utility. At this point, a human needs to judge: is this adjustment necessary? Which callers will be affected? Is the existing evidence sufficient to support it?

Scoping is an important engineering job:

What must be solved this time, what is allowed to be changed, what issues should be handled separately, and what conditions are sufficient to stop.

With a clear scope, AI's execution is easier to control, and the final result is easier to review.

四、在多个可行方案之间作选择

The same feature can usually be implemented in multiple ways.

You can modify existing logic directly, or add an extension layer; do it synchronously or asynchronously; reuse existing components or introduce a new dependency.

AI can help organize options, explain differences, and add risk notes. The human needs to make a decision based on the project's situation.

A design-elegant solution might require a refactoring cost the team can't afford right now; a direct implementation might be more suitable for the current scale; a solution that ships quickly might leave follow-up work that must be explicitly documented.

These choices involve time, complexity, stability, and team capability. They usually have no standard answer that is detached from context.

The human's value shows in judgment: for this project, this stage, this task, which approach is more appropriate.

五、验证"完成"究竟意味着什么

When AI says "it's fixed," that should be treated as a deliverable result that needs checking.

Developers need to further confirm:

• Whether the original issue can be reproduced.
• Whether the change passes the same scenarios.
• How exceptional inputs and boundary conditions are handled.
• Whether existing behavior is affected.
• Whether tests truly cover the requirements.

Pay special attention: code and tests might share the same incorrect understanding.

If AI misunderstands "only unpaid orders can be cancelled" as "all incomplete orders can be cancelled," it might also write tests according to that understanding. All tests pass, but the business rule is still wrong.

Therefore, verification needs to go back to independent references: acceptance criteria, existing interface conventions, explicit business rules, and observable runtime results.

Using another AI for review can add a check perspective; but ultimately you still need to verify the problems it points out and the evidence it provides.

六、保留对系统的理解

As code generation becomes easier, developers may face a new dilemma: the feature is done, but you can't explain why it works that way.

In normal times this seems not to affect usage, but when a failure occurs, the problem shows up. Why did data enter this state? Can it be retried after failure? Which step might be executed repeatedly? Where should rollback start from?

These questions require maintaining an understanding of the system.

After using AI, developers can reduce line-by-line input, but they still need to grasp key paths, data flow, external dependencies, and failure handling. For critical logic you cannot explain, keep reading, asking, and verifying.

Understanding doesn't require memorizing every detail. It requires the developer to be able to find evidence, judge impact, and take action when needed.

七、让一次交付成为下一次工作的基础

After a task ends, there is much worth organizing:

• Why this approach was chosen this time.
• Which evidence was most useful during troubleshooting.
• Which business rules were ambiguous.
• Which oversights can be added to a checklist.
• Which repetitive steps are suitable to hand over to tools.

AI can help organize these materials; humans need to filter what is truly worth keeping.

If every development effort re-explains the project, rediscovers conventions, and steps on the same pitfalls, even if an individual works quickly, the team will struggle to accumulate efficiency.

By distilling effective experience into project documentation, acceptance templates, checklists, or automation tools, the next collaboration can start from a better baseline.

人的工作，会更集中在判断和责任上

In AI Coding, humans will still write code, debug, and fix issues. But the focus of work will shift:

Work stage	What humans need to hold onto
Before starting	Define goals, scope, and acceptance criteria
During execution	Provide context, handle ambiguity, decide approaches
Before delivery	Verify results, check impact, decide whether to release
After delivery	Track actual effects, handle issues, distill experience

These tasks were already part of software development. AI accelerates implementation speed and makes them more prominent.

A vague goal can turn into a large amount of code faster; a wrong assumption can spread to multiple files faster. Therefore, developers need to spot directional problems earlier, express constraints more clearly, and use evidence to judge results.

When AI completes a change, the human ultimately needs to answer:

Is this the result we need? What basis do I have to believe it is correct? If something goes wrong, do I know how to handle it?

If you can answer these questions, you still own the delivery.