Claude Engineer Agent Master Tutorial: How to Avoid Being Rendered Incompetent by Over-Reliance on AI

AI is getting smarter, but humans are becoming lazier to use their brains!

Just now, Addy Osmani, former Director of Google Cloud AI and current Claude Code engineer, published a special article discussing this quite thought-provoking issue.

In his opinion, those engineers who command Agents to write code every day may have unconsciously fallen into a state — Cognitive Surrender.

To put it bluntly, you believe whatever AI outputs.

The code runs normally, all tests show green status, then you give the green light directly, "Approved!".

But when someone really asks why this piece of code is written in such a way, you cannot give a valid answer.

Therefore, this engineer who personally participated in developing AI programming tools decided to share a very interesting trick with everyone:

Let the Agent finish writing the code, then create several test questions for you.

Cannot answer the questions? Then don't rush to merge the code. (doge)

The smarter AI gets, the easier humans will get "spoiled and incompetent"

Who exactly is Addy Osmani?

He holds a master's degree from the University of Warwick in the UK, worked at Google for more than 14 years, participated in developer tool projects including Chrome DevTools and Lighthouse, and now he has joined Anthropic to work on Claude Code related businesses.

△

Besides, he is also a famous high-output creator of popular tutorials.

From Claude Code usage tips to Agent workflows and code review, new tutorials are released from him every few days.

But this time, he focused on a more and more realistic problem:

When the content generated by AI becomes more and more reliable, will humans still check it carefully?

In the past when we wrote code, we had to look up materials, think over solutions and debug manually all by ourselves.

But what about now?

Just send a Prompt, and the Agent can finish the work in a few minutes.

What's worse, with the improvement of model capabilities, the code written by AI is getting more and more decent.

Not only the variable naming is standard, the logic looks smooth, and all tests pass with green marks.

So people gradually get used to checking carefully for the first time, glancing over for the second time, and clicking pass directly for the third time...

Over time, humans no longer write code personally, but become the person who only stamps approval for Agents.

△

Addy describes this situation as Cognitive Surrender.

It does not happen overnight, but has a gradually deepening process.

At first, it may just be "Cognitive Offloading": we only hand over specific work to AI, but we still understand the task and can judge the result;

Then we start "Judgment Surrender", the answer given by AI gradually becomes the default basis for the next step of work;

Finally, we reach the stage of "Cognitive Surrender":

Okay okay, what AI says must be reasonable, just follow its advice.

At this point, we have completely handed over all the judgments that should have been completed by ourselves.

△

Addy gives a very typical example:

Suppose an Agent submits a 600-line code PR (Pull Request) at one go.

The developer takes a look, finds the structure is clear and all tests pass, then safely merges it.

Little do they know, the Agent may quietly modify the transaction processing order or adjust a certain boundary condition in an inconspicuous place.

These changes do not throw an error immediately at that time.

But when the system really goes wrong, developers suddenly find that they cannot even explain why this piece of code runs in such a way.

The most troublesome part is yet to come.

Addy believes that using Agents in this way for a long time will also accumulate a new type of technical debt — Comprehension Debt:

More and more code is written, and system functions become more and more complex.

But developers' understanding of the code does not grow accordingly.

So when it is really necessary to modify a certain function, people suddenly realize that although this code edifice has been built, fewer and fewer people can figure out its internal structure, they can only look at each other blankly, which is really frustrating.

Of course, this does not mean that you have to read every line of AI-generated code personally.

Addy also mentioned that the Claude Code team does not require engineers to remember the entire codebase at any time, they will use Claude to re-understand the relevant logic when they need to modify a certain part.

But there is a premise here:

You must know what you already understand and which parts you have not yet figured out.

Otherwise, the faster the code is written, the more Comprehension Debt you may accumulate.

Anti-addiction trick: Let the Agent test us in turn

So here comes the problem.

Agents are so good at writing code now, how on earth can we keep up with its speed?

Addy shared a lot of his practical experience in the long article.

The most interesting trick is to let the Agent become an examiner.

Let's assume that Claude has just completed a large-scale code modification.

Don't rush to click pass.

We can first ask it to summarize what has been modified this time and why these modifications are made, then create several test questions for us according to the modified content, and set a rule:

The code can only be merged after all the test questions are answered correctly.

In this way, we can truly know and understand what we have approved, and avoid unnecessary errors.

In addition, Addy also shared several other tricks, which I have sorted out for everyone ( ￣▽￣)σ.

Trick 1: Use your brain to list the requirement list before writing the Prompt

Addy mentioned that current Agents are really too good at completing unstated requirements.

Even if we haven't figured out what we want, it can still deliver a decent work.

But the problem lies exactly here: those unclear goals, restrictions and trade-offs in the requirements may be decided by AI for you without your awareness.

Addy calls this situation "Intent Debt".

So he suggests that before assigning a task, we'd better write a short requirement description in our own words.

Including who the work is for, what problems we want to solve, what things do not need to be done, and what standards we should meet to finish the task.

Think it through first, then let the Agent start working.

If you still can't get the desired result after adjusting the Prompt twice in a row, you should go back to sort out the requirements again instead of continuing to pile up more prompts.

Trick 2: Let the Agent voluntarily tell you what decisions it has made behind your back

This trick is especially suitable for long-running tasks.

Because during the execution process, the Agent may select default parameters by itself, adjust the implementation scope, and even make trade-offs when different requirements conflict.

It may not take the initiative to write these decisions into the final summary, and these decisions are even too natural to be noticed.

Therefore, instead of just asking "Is it finished?", Addy suggests that we continue to ask:

What decisions have you made that I did not explicitly authorize?

Which parts rely on your own assumptions?

What else has not been verified?

And, which modifications may affect other functions?

In this way, we can at least see clearly what trade-offs the Agent has made during the execution process, and then check the content confessed by the Agent step by step according to the code and test results.

Trick 3: Don't just look at the all-green test results, you also need to ask what it did not test

Addy specially reminds that the so-called green test results only prove that the covered conditions pass the test.