軟件開發中的 AI：哪些工作可自動化，哪些應由人主導

AI coding tools can generate code, explain unfamiliar functions, write tests, and help developers investigate bugs. But using AI across the entire development process without clear boundaries can create new problems instead of solving existing ones.

A generated function may look correct but fail on an edge case. A suggested fix may resolve a visible error while introducing a security issue. Documentation may sound convincing while describing behavior that the code does not actually support.

The challenge is not simply deciding whether to use AI. It is deciding where AI assistance adds value, where human judgment is essential, and how to verify the results.

A practical AI adoption strategy starts with that distinction.

1. Start With the Task, Not the AI Tool

When teams introduce AI into software development, they sometimes begin by asking, "Which tasks can we automate?"

A better question is:

"What part of our development workflow is repetitive, clearly defined, and easy to verify?"

This changes the conversation from adopting AI for its own sake to solving specific engineering problems.

For example, generating a basic unit test from a well-defined function may be a reasonable starting point. Asking AI to redesign a complex payment system without sufficient architectural context is a much higher-risk decision.

Before assigning a task to AI, consider four factors:

• Clarity: Can the task be described with specific requirements?
• Verifiability: Can the result be checked through tests, rules, or reliable references?
• Risk: What happens if the output is wrong?
• Context: Does the task require deep knowledge of the system, business rules, or user expectations?

The clearer and easier to verify a task is, the better suited it may be for AI assistance. As risk and the need for contextual judgment increase, human involvement should increase too.

2. Tasks AI Can Help Automate

AI is often most useful when it assists with bounded tasks that developers can review and validate.

Code scaffolding and repetitive code

AI can help generate boilerplate, basic functions, data transformations, and repetitive code patterns.

For example, a developer might ask an AI coding assistant to generate a simple API request handler based on an existing project pattern.

The developer should still verify error handling, input validation, compatibility with the codebase, and adherence to project conventions.

Good starting point: Let AI produce the first draft of predictable code, then validate it against the actual requirements.

Unit test generation

AI can suggest unit tests for known functions, including typical inputs, boundary conditions, and expected failures.

However, generated tests are not automatically correct. If the prompt describes the wrong behavior, AI may generate tests that reinforce the same misunderstanding.

A useful workflow is to:

1. Define the expected behavior independently.
2. Ask AI to suggest test cases.
3. Review whether important edge cases are covered.
4. Run the tests.
5. Add missing cases based on actual requirements.

The goal is not to generate the maximum number of tests. It is to improve meaningful test coverage.

Code explanation and exploration

Developers working in unfamiliar codebases can use AI to summarize functions, explain dependencies, or identify likely entry points for investigation.

This can make initial exploration more efficient, particularly when navigating a large repository.

But explanations should be treated as hypotheses rather than authoritative documentation. Verify important claims against the source code, configuration, tests, and actual runtime behavior.

Documentation drafts

AI can help create initial drafts of README sections, API usage examples, function descriptions, and setup instructions.

The human reviewer must ensure that examples work, configuration details are current, and the documentation reflects the implemented behavior.

Debugging assistance

AI can help interpret stack traces, suggest possible causes, and propose debugging steps.

For example, when an API request fails intermittently, AI might suggest checking timeouts, retry behavior, network dependencies, or error-handling logic.

These suggestions are starting points for investigation, not proof of the root cause. Developers still need logs, reproduction steps, and diagnostic evidence.

3. Tasks That Should Remain Human-Led

Some development activities require more than generating plausible output. They require accountability, trade-off analysis, and an understanding of consequences.

Architecture and system design

AI can compare design patterns, explain trade-offs, and suggest alternative implementations. But major architectural decisions should remain human-led.

A system design may need to account for:

• Existing infrastructure and technical debt
• Expected traffic and performance requirements
• Reliability and recovery requirements
• Integration constraints
• Long-term maintenance costs
• Business priorities and delivery timelines

AI may not have the complete context needed to balance these factors.

Use AI to explore options, but let engineers evaluate the trade-offs and own the decision.

Security-sensitive changes

Authentication, authorization, permissions, cryptographic operations, and handling of sensitive information deserve additional scrutiny.

AI-generated code can contain subtle security weaknesses even when it appears clean and passes basic tests.

For these tasks, use established security practices, appropriate automated checks, code review, and specialist review when necessary. Never treat an AI-generated security recommendation as sufficient evidence that a system is secure.

Business logic and product decisions

Software behavior often reflects rules that are not obvious from the code alone.

For example, an AI assistant might simplify a refund workflow but overlook a business rule involving partial refunds, transaction status, or approval requirements.

Product owners and domain experts should define the intended behavior. Developers should ensure that implementation and tests reflect those requirements.

Production releases and incident response

AI can summarize logs, suggest diagnostic queries, and help compare possible fixes. However, high-impact production changes require clear ownership and controlled validation.

Human decision-makers should determine whether a proposed change is safe to deploy, whether rollback plans are adequate, and whether the evidence supports the chosen fix.

The level of oversight should reflect the potential impact of failure.

4. A Practical Framework for Dividing Work Between AI and Humans

Instead of applying one rule to every development task, classify tasks according to risk and how reliably their results can be checked.

This is a practical starting framework, not a universal classification. A seemingly routine task can become high-risk depending on where it is used.

For example, generating a simple data transformation may be low-risk in an internal report but high-risk if it changes financial calculations.

The important distinction is not whether AI writes the code. It is who defines the requirements, verifies the outcome, and remains accountable for the result.

5. Example: Introducing AI Into a Development Team

Consider a hypothetical team maintaining a web application.

The team wants to use AI to reduce repetitive work but cannot afford regressions in production.

Rather than allowing unrestricted AI-generated changes, it introduces AI gradually.

Step 1: Choose a bounded use case

The team starts with generating unit-test suggestions for existing utility functions.

Step 2: Establish a baseline

Before introducing the workflow, the team records how long test creation typically takes and reviews the existing test coverage and defect patterns.

Step 3: Define the review process

Developers verify the proposed tests against requirements, correct inaccurate assumptions, and run the test suite.

Step 4: Evaluate the results

The team compares the time spent creating and reviewing tests, the usefulness of the added coverage, and any defects introduced by the process.

Step 5: Decide whether to expand

If the workflow provides a measurable benefit without reducing quality, the team can test another use case, such as documentation drafts or code explanations.

If review effort outweighs the benefit, the team can refine the process or choose a different task.

This example is hypothetical, but the decision-making process is applicable to real AI adoption projects: begin with a defined problem, establish a baseline, validate the result, and expand only when the evidence supports it.

6. Common Mistakes to Avoid

Several mistakes can undermine an otherwise useful AI-assisted development workflow.

Automating too much too early. Start with a small, well-defined task before introducing AI into critical workflows.

Measuring output instead of outcomes. Counting generated lines of code or prompts does not demonstrate improved engineering performance.

Trusting code because it looks correct. Readability is not proof of correctness, security, or maintainability.

Ignoring review effort. AI may save generation time while increasing the time required to validate, correct, and integrate its output.

Using the same policy for every task. Documentation drafts and production database migrations require different levels of control.

Failing to protect sensitive information. Teams should follow approved tool policies and avoid sharing credentials, confidential code, customer data, or other sensitive information with tools that are not authorized to process it.

7. Measure Whether AI Is Actually Helping

A successful AI workflow should improve an engineering outcome, not simply increase AI usage.

Choose metrics that match the task:

• Time to completion: How long does the task take, including AI interaction and review?
• Quality: Does the result meet requirements and pass relevant tests?
• Rework: How much correction is required after AI generates an output?
• Defects: Are more errors escaping into later testing or production?
• Developer experience: Does the workflow reduce tedious work or create additional cognitive overhead?

Establish a baseline before changing the workflow, and compare results across sufficiently similar tasks.

Where possible, evaluate both the time saved during generation and the effort required for verification. A faster first draft is not necessarily a faster overall process.

Also consider privacy, security, and maintainability. These requirements may be essential even when they cannot be reduced to a single productivity metric.

8. Make AI Adoption a Continuous Engineering Practice

AI adoption should not end when a tool is installed or employees complete a training session.

Teams need clear guidelines, opportunities to learn, and feedback loops that help them improve how AI is used.

A sustainable approach includes:

• Training developers to write clear task descriptions and verify outputs.
• Documenting which tools and data-handling practices are approved.
• Defining review and approval requirements based on risk.
• Sharing examples of useful workflows and mistakes to avoid.
• Reviewing results regularly and adjusting practices as tools and project requirements change.

The objective is not to remove human involvement from software development. It is to use AI where it provides genuine value while preserving the engineering judgment required to build reliable software.

Key Takeaways

• Use AI first for bounded, repetitive, and verifiable tasks.
• Keep humans responsible for architectural choices, security, critical business rules, and high-impact decisions.
• Match review requirements to the risk of the task.
• Measure total effort and quality, not just AI usage or code generation.
• Expand AI adoption gradually based on evidence and feedback.

AI works best as part of a well-designed engineering workflow—not as a substitute for understanding the problem.

Discussion question: If you could introduce AI into just one part of your software development workflow today, which task would you automate first, and which task would you deliberately keep human-led? Why?