Engineers Who Use AI and Those Who Don't: Two Distinct Types Now

In the past year, AI rapidly transformed from a "tool" into a "collaborator." However, many engineers gradually develop a dangerous illusion during its use: AI can replace decision-making, and even responsibility.

The reality is quite the opposite. The more capable the AI, the more it demands stronger constraint abilities, judgment, and communication skills from humans.

If we treat AI as an "infinitely amplified junior engineer," then how to use it correctly can be abstracted into a set of information flow design problems.

In this article, I will try to redefine the boundaries of human-AI collaboration from an engineering perspective.

1. More Input Isn't Better; Precision Is Better

Many people's first reaction when using AI is: dump all the context in at once.

But in engineering systems, we know very well that redundant information pollutes signals.

It's the same with AI.

When you provide:

• Vague requirements

• Irrelevant context

• Unfiltered logs or code

• Multiple rounds of accumulated but unorganized information

You are effectively increasing "reasoning noise."

A better approach is:

• Provide Minimum Sufficient Context

• Clearly define task boundaries (input / output / constraints)

• Remove information unrelated to the goal

For example:

Wrong way: "Here's my entire project code. Help me find where the issues are."

Correct way: "In a Next.js App Router, a Server Component calls an API and causes a hydration mismatch. Here is the minimal reproduction code + error log. Please analyze the cause."

The quality of AI depends largely on whether you design your input as carefully as you design an API.

2. Don't Let AI Decide the Deliverable

A common misconception is: "Help me design a system" "Help me implement a complete solution"

And then directly copy the result into production.

This essentially outsources the "decision-making power" to AI.

The problem is: AI is good at generating "reasonable answers," but it does not guarantee the "optimal solution" or "the solution suited for your scenario."

There is an important principle in engineering: decisions must be made by the responsible party.

The correct collaboration should be:

• AI provides candidate options

• AI presents trade-offs (pros and cons)

• Humans make the final choice

For example:

Instruct AI: "Give me 3 approaches to implement MCP server routing, and analyze their complexity, scalability, and deployment cost."

Instead of: "Write me an MCP server routing system."

The former enhances your judgment; the latter weakens it.

3. Use AI to "Understand Problems," Not to "Complete Tasks for You"

The strongest capability of AI is actually not writing code, but:

• Decomposing problems

• Providing knowledge paths

• Explaining complex concepts

• Constructing solution spaces

But "choosing the path + verifying the result" must be done by humans.

A healthy workflow should be:

1. Use AI to explore the problem space

2. Decide on the solution yourself

3. Then have AI assist in implementation

4. Humans are responsible for verification and convergence

If you skip steps 2 and 4, typical issues arise:

• The code runs, but you don't know why

• The system works but is not maintainable

• When problems occur, you cannot debug

Essentially, you hand over the "cognitive loop" to AI.

4. Redesign the Information Flow: Who Is Responsible for What

The collaboration between humans and AI can be abstracted into an information flow system:

AI → Human:

• Provide insights

• Provide approaches

• Provide optional paths

Human → AI:

• Define clear objectives

• Set constraints

• Provide verification results (feedback / evaluation)

The key is: AI is responsible for "divergence," humans for "convergence."

Once this direction is reversed, the result is:

• AI output becomes increasingly random

• Humans become increasingly dependent

• The system eventually becomes uncontrollable

5. Core Principles for Engineering AI Usage

To summarize into a few engineering principles:

1. Treat prompts as interface design, not conversation

2. Treat AI as a "candidate generator," not a "decision maker"

3. Always retain the final decision authority for humans

4. Mandate establishing verification loops (test / review / benchmark)

5. Prioritize improving "question-asking ability" over "copying ability"

In the long run, the real difference won't come from "who can write code faster with AI," but from "who knows better how to constrain AI."

Conclusion

AI will not replace engineers, but it will amplify the gap between them.

Those who cannot ask the right questions will get seemingly correct answers; those who know how to design information flow will get truly usable systems.

At this stage, the truly important ability is no longer "writing code," but: defining problems, constraining systems, and making judgments.

These three things cannot be outsourced in the short term, and that is exactly the dividing line between ordinary engineers and outstanding engineers.