DeepSeek Researcher Summarizes 10 Rules for Using AI Agents

A DeepSeek researcher recently shared his experience using AI agents in AI research and autonomous programming, distilling 10 universal rules that cover common pitfalls and key considerations. These battle-tested insights from a frontline researcher are invaluable for anyone currently using or about to start using AI agents.

AI agents refer to AI systems capable of autonomously perceiving their environment, making decisions, and executing actions—distinct from traditional conversational AI. Agents typically possess capabilities like tool calling, multi-step reasoning, and autonomous planning, enabling them to independently complete complex task chains. In programming scenarios, AI agents can autonomously read codebases, write code, run tests, and fix bugs, forming a complete development loop. Notable examples include Devin, Claude Code, and Cursor Agent. It's precisely this end-to-end autonomous execution capability that prompted the researcher's profound reflections on "judgment" discussed below.

The Core Shift: The Bottleneck Moves from Execution to Judgment

The researcher offers a penetrating observation: AI agents have eliminated the execution bottleneck, but the new bottleneck is your judgment. Because you can now create an infinite number of things, the key question becomes whether you can judge what's worth creating.

In the past, execution-level work—boilerplate code, debugging, module integration—would consume your entire day. But now, the real bottleneck has become your attention allocation: you need to switch between multiple tasks and multiple coding threads, exercising judgment and taste to decide what truly matters.

The deeper implication of this shift is: when execution costs approach zero, "what to build" becomes ten thousand times more important than "how to build it." In the past, a wrong technical decision might waste a week. Now, a wrong directional judgment can produce thousands of lines of useless code in just hours—and because that code looks high-quality, it's even harder to realize the direction itself was wrong.

Thinking speed, not typing speed, is the decisive factor.

Role Redefined: From Builder to Architect

The researcher emphasizes that using AI agents fundamentally transforms your role—you're no longer a builder or coder, but an architect and diplomat. This means you need to:

• Think clearly about objectives: Define the project's core goals, logic, and priorities
• Eliminate clutter: Strip away everything unnecessary and keep the project focused
• Communicate effectively: Align goals with team members and coordinate the work of multiple agents

This metaphor is remarkably precise. An architect doesn't need to lay every brick by hand, but must ensure the entire building's structure is sound. A diplomat doesn't need to execute every decision, but must ensure all parties are moving in the same direction.

From a software engineering perspective, this effectively shifts a developer's center of gravity from the "implementation layer" up to the "design layer" and "decision layer." Traditional software architects need years of experience to be effective because they must simultaneously maintain both a global view and local details of the system in their minds. In the age of AI agents, even relatively junior developers are forced to take on architectural decision-making responsibilities—because agents can rapidly implement any design, but they can't judge which design is correct for you.

Warning: AI Amplifies Everything About You, Including Bad Habits

This may be one of the most important warnings in the entire piece: AI agents amplify everything, including your worst habits.

Specific manifestations include:

• More branches: You'll open too many directions simultaneously
• More rabbit holes: You'll dive into unnecessary details
• More scope creep: You'll do things beyond the project's scope
• More chaos: You'll move faster than ever before, but possibly in the wrong direction

Scope creep is a classic project management problem where new requirements and features are continuously added during execution, causing the project scope to far exceed the original plan. In the age of AI agents, this problem is massively amplified—because the marginal cost of implementing any feature drops dramatically, developers easily fall into the "it'll only take a minute" mindset, continuously adding new features until the project loses focus, the codebase bloats, and maintenance costs skyrocket. A core feature that could have been completed in two days might balloon into a two-week monstrosity due to constant "while I'm at it" additions.

"You'll sprint faster than ever before, but you might be sprinting in the wrong direction." This line deserves repeated reflection from every heavy AI tool user.

Practical Advice: Build a Memory File System

The researcher recommends a highly practical method: maintain a Memory File. Record every decision, plan, and goal you make in a blank file, so you don't need to re-provide context to the AI every time.

The technical background of this method is worth understanding in depth. Even the most advanced large language models have limited context windows (e.g., Claude's 200K tokens, GPT-4's 128K tokens). When project complexity exceeds the context window capacity, the AI "forgets" earlier information, leading to inconsistent decisions or repeated mistakes. A memory file is essentially an external persistent storage solution, similar to Architecture Decision Records (ADR) in software engineering, but with format and structure optimized specifically for AI agent consumption. Cursor's .cursorrules file, Claude's CLAUDE.md, and Windsurf's .windsurfrules are all concrete product implementations of this concept.

The core value of this method lies in:

1. Reducing context-switching costs: AI agents can directly read the memory file and quickly get up to speed, avoiding the need to explain project background from scratch in every conversation
2. Maintaining decision consistency: All historical decisions are documented and traceable, preventing contradictions. When an agent makes a suggestion in the 50th conversation that contradicts the 3rd conversation, the memory file can serve as the "source of truth" for correction
3. Team alignment: Human members can align on goals through a shared memory file, then let multiple agents work independently, each reading the same memory file to maintain directional consistency

The Boundary of Human-AI Collaboration: Who Makes the Final Call?

Regarding AI agent output, the researcher lays down an iron rule: The agent is responsible for output, but not for judgment. The power of judgment rests with you. Agent output is not truth.

He also mentions that creators like those behind OpenClaw are already using agents for verification work—such as having agents automatically click through websites and check functionality. So in the future, verification work may also be delegated to agents, but project judgment and taste always belong to humans.

The concept of "taste" here is worth deep reflection. In the technical domain, taste means choosing the most elegant, most maintainable, and most user-aligned solution among multiple technically viable options. This ability stems from accumulated experience, deep understanding of users, and intuitive judgment about technology trends—all forms of tacit knowledge that current AI models struggle to fully acquire.

Collaboration Advantages Between Agents

An interesting observation: communication between agents is actually more efficient than communication between humans. Human communication is slower and messier, while agents can rapidly exchange information through structured means. This implies that in multi-agent collaboration scenarios, efficiency gains could be exponential.

From a technical perspective, Multi-Agent Collaboration is a cutting-edge direction in current AI engineering. The core idea is to decompose complex tasks across multiple specialized agents, each responsible for specific subtasks—for example, one handling frontend, one handling backend, and one handling testing. Agents communicate through structured messages (such as JSON, function calls), avoiding the ambiguity and information loss inherent in human natural language communication. OpenAI's Swarm framework, Microsoft's AutoGen, and CrewAI are all representative multi-agent orchestration frameworks. The core advantage of this architecture lies in parallelization—multiple agents can simultaneously process different modules, while human teams are constrained by meetings, communication delays, and cognitive load, making truly parallel development difficult to achieve.

Human Growth Is Irreplaceable

The researcher raises a seemingly paradoxical but profound point: Both humans and tools are growing, but currently humans may be growing faster. Therefore, don't use tools to replace people—instead, think clearly about where you need humans and where you need tools.

This judgment is reasonable at the current stage. Large language models are indeed advancing rapidly, but human capabilities in understanding business logic, grasping project direction, and making value judgments remain areas that AI cannot fully replace in the short term. More importantly, human growth has a compound interest effect—the project experience a developer gains today by accelerating work through AI agents internalizes into better judgment and architectural ability tomorrow. Meanwhile, AI model "growth" depends on the next training iteration and cannot accumulate experience within a single use session. This means that people who skillfully leverage AI tools will have a steeper personal capability growth curve than those who don't, creating a positive flywheel.

The Most Important Skill: Knowing When to Stop

Finally, the researcher shares what he considers the most important skill of this era:

Know what you're doing, why you're doing it, and when to stop.

After working with agents for several hours, you'll experience fatigue from continuous decision-making and context switching, and your performance will start to decline—even if you don't realize it yourself.

This phenomenon is known in cognitive psychology as "Decision Fatigue." Research shows that humans have a limited capacity for high-quality decisions each day—which is why many CEOs simplify trivial decisions like daily clothing to preserve cognitive resources for what truly matters. In AI agent collaboration scenarios, users need to continuously review code, evaluate solutions, and make trade-offs. This high-density decision-making mode accelerates cognitive resource depletion. What's more dangerous is that decision fatigue is often imperceptible—you won't feel tired the way you do with physical exhaustion, but the quality of your judgment is already quietly declining.

So the core principle is: Master the tool, don't let the tool master you.

AI agents can amplify your strengths, but they can also amplify your weaknesses and time wasted across different projects. In this era of exploding AI capabilities, self-discipline and self-awareness have paradoxically become the scarcest abilities. As this DeepSeek researcher reveals: the ceiling of technological tools keeps rising, but human wisdom in using tools—knowing when to use them, how to use them, and when to stop—is the key variable that truly determines output quality.